Revert "Add basic support for the (mostly x86_64 compatible) Elbrus E2000 architecture"

.cirrus.yml

@@ -1,177 +0,0 @@
-#macos_instance:
-#  image: ghcr.io/cirruslabs/macos-monterey-xcode:latest
-#
-#task:
-#  name: AppleM1/LLVM
-#  compile_script:
-#  - brew install llvm
-#  - export PATH=/opt/homebrew/opt/llvm/bin:$PATH
-#  - export LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
-#  - export CPPFLAGS="-I/opt/homebrew/opt/llvm/include"
-#  - make TARGET=VORTEX USE_OPENMP=1 CC=clang
-#
-#task:
-#  name: AppleM1/LLVM/ILP64
-#  compile_script:
-#  - brew install llvm
-#  - export PATH=/opt/homebrew/opt/llvm/bin:$PATH
-#  - export LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
-#  - export CPPFLAGS="-I/opt/homebrew/opt/llvm/include"
-#  - make TARGET=VORTEX USE_OPENMP=1 CC=clang INTERFACE64=1
-#
-#task:
-#  name: AppleM1/LLVM/CMAKE
-#  compile_script:
-#  - brew install llvm
-#  - export PATH=/opt/homebrew/opt/llvm/bin:$PATH
-#  - export LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
-#  - export CPPFLAGS="-I/opt/homebrew/opt/llvm/include"
-#  - mkdir build
-#  - cd build
-#  - cmake -DTARGET=VORTEX -DCMAKE_C_COMPILER=clang -DBUILD_SHARED_LIBS=ON ..
-#  - make -j 4
-#
-#task:
-#  name: AppleM1/GCC/MAKE/OPENMP
-#  compile_script:
-#  - brew install gcc@11
-#  - export PATH=/opt/homebrew/bin:$PATH
-#  - export LDFLAGS="-L/opt/homebrew/lib"
-#  - export CPPFLAGS="-I/opt/homebrew/include"
-#  - make CC=gcc-11 FC=gfortran-11 USE_OPENMP=1
-#  
-#macos_instance:
-#  image: ghcr.io/cirruslabs/macos-sonoma-xcode:latest
-#task:
-#  name: AppleM1/LLVM x86_64 xbuild
-#  compile_script:
-#  - #brew install llvm
-#  - export #PATH=/opt/homebrew/opt/llvm/bin:$PATH
-#  - export #LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
-#  - export #CPPFLAGS="-I/opt/homebrew/opt/llvm/include" 
-#  - export ARCHS="i386 x86_64"
-#  - export ARCHS_STANDARD="i386 x86_64"
-#  - export ARCHS_STANDARD_32_64_BIT="i386 x86_64"
-#  - export ARCHS_STANDARD_64_BIT=x86_64
-#  - export ARCHS_STANDARD_INCLUDING_64_BIT="i386 x86_64"
-#  - export ARCHS_UNIVERSAL_IPHONE_OS="i386 x86_64"
-#  - export VALID_ARCHS="i386 x86_64"
-#  - xcrun --sdk macosx --show-sdk-path
-#  - xcodebuild -version
-#  - export CC=/Applications/Xcode_26.0.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-#  - export CFLAGS="-O2 -unwindlib=none -Wno-macro-redefined -isysroot /Applications/Xcode_26.0.1.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX26.0.sdk -arch x86_64"
-#  - make TARGET=CORE2 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 RANLIB="ls -l"
-#  always:
-#    config_artifacts:
-#      path: "*conf*"
-#      type: text/plain
-#  lib_artifacts:
-#    path: "libopenblas*"
-#    type: application/octet-streamm
-#
-#macos_instance:
-#  image: ghcr.io/cirruslabs/macos-sonoma-xcode:latest
-#task:
-#  name: AppleM1/LLVM armv8-ios xbuild
-#  compile_script:
-#  - #brew install llvm
-#  - export #PATH=/opt/homebrew/opt/llvm/bin:$PATH
-#  - export #LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
-#  - export #CPPFLAGS="-I/opt/homebrew/opt/llvm/include" 
-#  - export CC=/Applications/Xcode_26.0.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-#  - export CFLAGS="-O2 -unwindlib=none -Wno-macro-redefined -isysroot /Applications/Xcode_26.0.1.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS26.0.sdk -arch arm64 -miphoneos-version-min=10.0"
-#  - xcrun --sdk iphoneos --show-sdk-path
-#  - ls -l /Applications
-#  - make TARGET=ARMV8 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 CROSS=1
-#  always:
-#    config_artifacts:
-#      path: "*conf*"
-#      type: text/plain
-#
-#macos_instance:
-#  image: ghcr.io/cirruslabs/macos-tahoe-xcode:latest
-#task:
-#  name: AppleM1/LLVM armv7-androidndk xbuild
-#  compile_script:
-#  - brew install --cask android-ndk
-#  - export ANDROID_NDK_HOME="/opt/homebrew/share/android-ndk"
-#  - export CC=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/armv7a-linux-androideabi23-clang
-#  - export AR=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-ar
-#  - export RANLIB=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-ranlib
-#  - make TARGET=ARMV7 ARM_SOFTFP_ABI=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1
-#  always:
-#    config_artifacts:
-#      path: "*conf*"
-#      type: text/plain
-#
-#task:
-#  name: NeoverseN1
-#  arm_container:
-#    image: node:latest
-#  compile_script:
-#  - make
-#
-#  task:
-#  name: NeoverseN1-ILP64
-#  arm_container:
-#    image: node:latest
-#  compile_script:
-#  - make INTERFACE64=1
-#
-#task:
-#  name: NeoverseN1-OMP
-#  arm_container:
-#    image: node:latest
-#    cpu: 8
-#  compile_script:
-#  - make USE_OPENMP=1
-#
-#
-#FreeBSD_task:
-#  name: FreeBSD-gcc
-#  freebsd_instance:
-#    image_family: freebsd-14-3
-#  install_script:
-#  - pkg update -f && pkg upgrade -y && pkg install -y gmake gcc
-#  compile_script:
-#  - ls -l /usr/local/lib
-#  - gmake CC=gcc 
-#
-#
-#FreeBSD_task:
-#  name: freebsd-gcc-ilp64
-#  freebsd_instance:
-#    image_family: freebsd-14-3
-#  install_script:
-#  - pkg update -f && pkg upgrade -y && pkg install -y gmake gcc
-#  compile_script:
-#  - ls -l /usr/local/lib
-#  - gmake CC=gcc INTERFACE64=1
-#
-#FreeBSD_task:
-#  name: FreeBSD-clang-openmp
-#  freebsd_instance:
-#    image_family: freebsd-14-3
-#  install_script:
-#  - pkg update -f && pkg upgrade -y && pkg install -y gmake gcc 
-#  - ln -s /usr/local/lib/gcc14/libgfortran.so.5.0.0 /usr/lib/libgfortran.so
-#  compile_script:
-#  - gmake CC=clang FC=gfortran USE_OPENMP=1 CPP_THREAD_SAFETY_TEST=1
-#
-#task:
-#  name: Windows/LLVM16     --- too slow ---
-#  windows_container:
-#    image: cirrusci/windowsservercore:cmake-2021.12.07
-#  install_script: 
-#    - choco list --localonly
-#    - choco install -y llvm
-#    - # choco install -y cmake --installargs '"ADD_CMAKE_TO_PATH=System"'
-#    - choco install -y ninja
-#    - refreshenv
-#    - cd "c:/Program Files (x86)/Microsoft Visual Studio/2019/BuildTools/VC/Auxiliary/Build"
-#    - vcvarsall x64
-#    - cd "C:\Users\ContainerAdministrator\AppData\Local\Temp\cirrus-ci-build"
-#    - cmake -S . -B build -G "Ninja" -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_C_COMPILER=clang-cl -DCMAKE_MT=mt -DCMAKE_BUILD_TYPE=Release
-#    - cd build
-#    - cmake --build .
-#    - ctest

.cirun.yml

@@ -1,16 +0,0 @@
-# Self-Hosted Github Action Runners on AWS via Cirun.io
-# Reference: https://docs.cirun.io/reference/yaml
-runners:
-  - name: "aws-runner-graviton"
-    # Cloud Provider: AWS
-    cloud: "aws"
-    region: "us-east-1"
-    # Cheapest VM on AWS
-    instance_type: "c7g.large"
-    # Ubuntu-22.04, ami image
-    machine_image: "ami-0a0c8eebcdd6dcbd0"
-    preemptible: false
-    # Add this label in the "runs-on" param in .github/workflows/<workflow-name>.yml
-    # So that this runner is created for running the workflow
-    labels:
-      - "cirun-aws-runner-graviton"

.github/workflows/apple_m.yml

@@ -1,303 +0,0 @@
-name: apple m
-
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  build-windows:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: macos-14
-
-    strategy:
-      fail-fast: false
-      matrix:
-        build: [cmake, make]
-        fortran: [gfortran]
-        openmp: [0, 1]
-        ilp64: [0, 1]
-        
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Print system information
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            cat /proc/cpuinfo
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            sysctl -a | grep machdep.cpu
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Install Dependencies
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            sudo apt-get install -y gfortran cmake ccache libtinfo5
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            # It looks like "gfortran" isn't working correctly unless "gcc" is re-installed.
-            brew reinstall gcc
-            brew install coreutils ccache
-            brew install llvm
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          # We include the commit sha in the cache key, as new cache entries are
-          # only created if there is no existing entry for the key yet.
-          # GNU make and cmake call the compilers differently. It looks like
-          # that causes the cache to mismatch. Keep the ccache for both build
-          # tools separate to avoid polluting each other.
-          key: ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}-${{ github.ref }}-${{ github.sha }}
-          # Restore a matching ccache cache entry. Prefer same branch and same Fortran compiler.
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.build }}-${{matrix.fortran }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.build }}-${{matrix.fortran }}
-            ccache-${{ runner.os }}-${{ matrix.build }}
-
-      - name: Configure ccache
-        run: |
-          if [ "${{ matrix.build }}" = "make" ]; then
-            # Add ccache to path
-            if [ "$RUNNER_OS" = "Linux" ]; then
-              echo "/usr/lib/ccache" >> $GITHUB_PATH
-            elif [ "$RUNNER_OS" = "macOS" ]; then
-              echo "$(brew --prefix)/opt/ccache/libexec" >> $GITHUB_PATH
-              echo "/opt/homebrew/opt/llvm/bin" >>$GITHUB_PATH
-              echo "" >>$GITHUB_PATH
-            else
-              echo "::error::$RUNNER_OS not supported"
-              exit 1
-            fi
-          fi
-          # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota (5 GB).
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-          
-      - name: Add gfortran runtime to link path
-        if: matrix.build == 'make' && runner.os == 'macOS'
-        run: |
-          GFORTRAN_LIBDIR=$(gfortran -print-file-name=libgfortran.dylib | xargs dirname)
-          echo "Using gfortran runtime in $GFORTRAN_LIBDIR"
-          echo "LDFLAGS=-L/opt/homebrew/opt/llvm/lib -L$GFORTRAN_LIBDIR" >> $GITHUB_ENV
-
-      - name: Build OpenBLAS
-        run: |
-          export CPPFLAGS="-I/opt/homebrew/opt/llvm/include"
-          export CC="/opt/homebrew/opt/llvm/bin/clang"
-          export RANLIB=llvm-ranlib
-          case "${{ matrix.build }}" in
-            "make")
-              make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=${{matrix.openmp}} INTERFACE64=${{matrix.ilp64}} FC="ccache ${{ matrix.fortran }}"
-              ;;
-            "cmake")
-              export LDFLAGS="$LDFLAGS -Wl,-ld_classic"
-              mkdir build && cd build
-              cmake -DDYNAMIC_ARCH=1 \
-                    -DUSE_OPENMP=${{matrix.openmp}} \
-                    -DOpenMP_Fortran_LIB_NAMES=omp \
-                    -DINTERFACE64=${{matrix.ilp64}} \
-                    -DNOFORTRAN=0 \
-                    -DBUILD_WITHOUT_LAPACK=0 \
-                    -DCMAKE_VERBOSE_MAKEFILE=ON \
-                    -DCMAKE_BUILD_TYPE=Release \
-                    -DCMAKE_Fortran_COMPILER=${{ matrix.fortran }} \
-                    -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-                    -DCMAKE_Fortran_COMPILER_LAUNCHER=ccache \
-                    ..
-              cmake --build .
-              ;;
-            *)
-              echo "::error::Configuration not supported"
-              exit 1
-              ;;
-          esac
-
-      - name: Show ccache status
-        continue-on-error: true
-        run: ccache -s
-
-      - name: Run tests
-        timeout-minutes: 60
-        run: |
-          case "${{ matrix.build }}" in
-            "make")
-              MAKE_FLAGS='DYNAMIC_ARCH=1 USE_OPENMP=0'
-              echo "::group::Tests in 'test' directory"
-              make -C test $MAKE_FLAGS FC="ccache ${{ matrix.fortran }}"
-              echo "::endgroup::"
-              echo "::group::Tests in 'ctest' directory"
-              make -C ctest $MAKE_FLAGS FC="ccache ${{ matrix.fortran }}"
-              echo "::endgroup::"
-              echo "::group::Tests in 'utest' directory"
-              make -C utest $MAKE_FLAGS FC="ccache ${{ matrix.fortran }}"
-              echo "::endgroup::"
-              ;;
-            "cmake")
-              cd build && ctest
-              ;;
-            *)
-              echo "::error::Configuration not supported"
-              exit 1
-              ;;
-          esac
-
-  xbuild-x86_64:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: macos-26
-
-    strategy:
-      fail-fast: false
-        
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Print system information
-        run: |
-          if [ "$RUNNER_OS" == "macOS" ]; then
-            sysctl -a | grep machdep.cpu
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Install Dependencies
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            sudo apt-get install -y gfortran cmake ccache libtinfo5
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            # It looks like "gfortran" isn't working correctly unless "gcc" is re-installed.
-            brew reinstall gcc
-            brew install coreutils ccache
-            brew install llvm
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-          
-      - name: Crossbuild OpenBLAS to x86_64
-        run: |
-          #export PATH=/opt/homebrew/opt/llvm/bin:$PATH
-          #export LDFLAGS="-L/opt/homebrew/opt/llvm/lib"
-          #export CPPFLAGS="-I/opt/homebrew/opt/llvm/include" 
-          export ARCHS="i386 x86_64"
-          export ARCHS_STANDARD="i386 x86_64"
-          export ARCHS_STANDARD_32_64_BIT="i386 x86_64"
-          export ARCHS_STANDARD_64_BIT=x86_64
-          export ARCHS_STANDARD_INCLUDING_64_BIT="i386 x86_64"
-          export ARCHS_UNIVERSAL_IPHONE_OS="i386 x86_64"
-          export VALID_ARCHS="i386 x86_64"
-          xcrun --sdk macosx --show-sdk-path
-          xcodebuild -version
-          export CC=/Applications/Xcode_26.0.1.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-          export CFLAGS="-O2 -unwindlib=none -Wno-macro-redefined -isysroot /Applications/Xcode_26.0.1.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX26.0.sdk -arch x86_64"
-          make TARGET=CORE2 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 RANLIB="ls -l"
-
-  xbuild-ios:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: macos-26
-
-    strategy:
-      fail-fast: false
-        
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Print system information
-        run: |
-          if [ "$RUNNER_OS" == "macOS" ]; then
-            sysctl -a | grep machdep.cpu
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Install Dependencies
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            sudo apt-get install -y gfortran cmake ccache libtinfo5
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            # It looks like "gfortran" isn't working correctly unless "gcc" is re-installed.
-            brew reinstall gcc
-            brew install coreutils ccache
-            brew install llvm
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Crossbuild to iOS
-        run: |
-          CC="$(xcrun --sdk iphoneos --find clang)"
-          SDKROOT="$(xcrun --sdk iphoneos --show-sdk-path)"
-          echo "CC=${CC}"
-          echo "SDKROOT=${SDKROOT}"
-          make TARGET=ARMV8 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1 \
-            CC="${CC}" CFLAGS="-O2 -Wno-macro-redefined -isysroot ${SDKROOT} -arch arm64 -miphoneos-version-min=10.0"
-
-  xbuild-ios32:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: macos-26
-
-    strategy:
-      fail-fast: false
-        
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Print system information
-        run: |
-          if [ "$RUNNER_OS" == "macOS" ]; then
-            sysctl -a | grep machdep.cpu
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Install Dependencies
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            sudo apt-get install -y gfortran cmake ccache libtinfo5
-          elif [ "$RUNNER_OS" == "macOS" ]; then
-            # It looks like "gfortran" isn't working correctly unless "gcc" is re-installed.
-            brew reinstall gcc
-            brew install coreutils ccache
-            brew install llvm
-            brew install --cask android-ndk
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: AppleM1/LLVM armv7-androidndk xbuild
-        run: |
-          export ANDROID_NDK_HOME="/opt/homebrew/share/android-ndk"
-          export CC=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/armv7a-linux-androideabi23-clang
-          export AR=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-ar
-          export RANLIB=/opt/homebrew/share/android-ndk/toolchains/llvm/prebuilt/darwin-x86_64/bin/llvm-ranlib
-          make TARGET=ARMV7 ARM_SOFTFP_ABI=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1

.github/workflows/arm64_graviton.yml

@@ -1,146 +0,0 @@
-name: arm64 graviton cirun
-
-on:
-  push:
-    branches:
-      - develop
-      - release-**
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    branches:
-      - develop
-      - release-**
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: "cirun-aws-runner-graviton--${{ github.run_id }}"
-
-    strategy:
-      fail-fast: false
-      matrix:
-        fortran: [gfortran]
-        build: [cmake, make]
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Print system information
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            cat /proc/cpuinfo
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Install Dependencies
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            sudo apt update
-            sudo apt-get install -y gfortran cmake ccache libtinfo5
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          # We include the commit sha in the cache key, as new cache entries are
-          # only created if there is no existing entry for the key yet.
-          # GNU make and cmake call the compilers differently. It looks like
-          # that causes the cache to mismatch. Keep the ccache for both build
-          # tools separate to avoid polluting each other.
-          key: ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}-${{ github.ref }}-${{ github.sha }}
-          # Restore a matching ccache cache entry. Prefer same branch and same Fortran compiler.
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}
-            ccache-${{ runner.os }}-${{ matrix.build }}
-
-      - name: Configure ccache
-        run: |
-          if [ "${{ matrix.build }}" = "make" ]; then
-            # Add ccache to path
-            if [ "$RUNNER_OS" = "Linux" ]; then
-              echo "/usr/lib/ccache" >> $GITHUB_PATH
-            else
-              echo "::error::$RUNNER_OS not supported"
-              exit 1
-            fi
-          fi
-          # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota (5 GB).
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-
-      - name: Build OpenBLAS
-        run: |
-          case "${{ matrix.build }}" in
-            "make")
-              make -j$(nproc) DYNAMIC_ARCH=1 BUILD_BFLOAT16=1 USE_OPENMP=0 FC="ccache ${{ matrix.fortran }}"
-              ;;
-            "cmake")
-              mkdir build && cd build
-              cmake -DDYNAMIC_ARCH=1 \
-                    -DNOFORTRAN=0 \
-                    -DBUILD_WITHOUT_LAPACK=0 \
-                    -DBUILD_BFLOAT16=1 \
-                    -DCMAKE_VERBOSE_MAKEFILE=ON \
-                    -DCMAKE_BUILD_TYPE=Release \
-                    -DCMAKE_Fortran_COMPILER=${{ matrix.fortran }} \
-                    -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-                    -DCMAKE_Fortran_COMPILER_LAUNCHER=ccache \
-                    ..
-              cmake --build .
-              ;;
-            *)
-              echo "::error::Configuration not supported"
-              exit 1
-              ;;
-          esac
-
-      - name: Show ccache status
-        continue-on-error: true
-        run: ccache -s
-
-      - name: Run tests
-        timeout-minutes: 60
-        run: |
-          case "${{ matrix.build }}" in
-            "make")
-              MAKE_FLAGS='DYNAMIC_ARCH=1 USE_OPENMP=0'
-              echo "::group::Tests in 'test' directory"
-              make -C test $MAKE_FLAGS FC="ccache ${{ matrix.fortran }}"
-              echo "::endgroup::"
-              echo "::group::Tests in 'ctest' directory"
-              make -C ctest $MAKE_FLAGS FC="ccache ${{ matrix.fortran }}"
-              echo "::endgroup::"
-              echo "::group::Tests in 'utest' directory"
-              make -C utest $MAKE_FLAGS FC="ccache ${{ matrix.fortran }}"
-              echo "::endgroup::"
-              ;;
-            "cmake")
-              cd build && ctest
-              ;;
-            *)
-              echo "::error::Configuration not supported"
-              exit 1
-              ;;
-          esac

.github/workflows/c910v.yml

@@ -1,170 +0,0 @@
-name: c910v qemu test
-
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  TEST:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-latest
-    env:
-      xuetie_toolchain: https://occ-oss-prod.oss-cn-hangzhou.aliyuncs.com/resource//1698113812618
-      toolchain_file_name: Xuantie-900-gcc-linux-5.10.4-glibc-x86_64-V2.8.0-20231018.tar.gz
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - target: RISCV64_GENERIC
-            triple: riscv64-linux-gnu
-            apt_triple: riscv64-linux-gnu
-            opts: NO_SHARED=1 TARGET=RISCV64_GENERIC
-          - target: C910V
-            triple: riscv64-unknown-linux-gnu
-            apt_triple: riscv64-linux-gnu
-            opts: NO_SHARED=1 TARGET=C910V
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: install build deps
-        run: |
-          sudo apt-get update
-          sudo apt-get install autoconf automake autotools-dev ninja-build make ccache \
-          gcc-${{ matrix.apt_triple }} gfortran-${{ matrix.apt_triple }} libgomp1-riscv64-cross libglib2.0-dev
-
-      - name: checkout qemu
-        uses: actions/checkout@v6
-        with:
-          repository: XUANTIE-RV/qemu
-          path: qemu
-          ref: e0ace167effcd36d1f82c7ccb4522b3126011479 # xuantie-qemu-9.0
-
-      - name: build qemu
-        run: |
-          # Force use c910v qemu-user
-          wget https://github.com/revyos/qemu/commit/222729c7455784dd855216d7a2bec4bd8f2a6800.patch
-          # Backport the upstream linux-user clone_lock fix
-          wget -O qemu-clone-lock.patch https://gitlab.com/qemu-project/qemu/-/commit/d22e9aec572396836782e993cb18d598e6012688.patch
-          cd qemu
-          patch -p1 < ../222729c7455784dd855216d7a2bec4bd8f2a6800.patch
-          patch -p1 < ../qemu-clone-lock.patch
-          export CXXFLAGS="-Wno-error"; export CFLAGS="-Wno-error"
-          ./configure --prefix=$GITHUB_WORKSPACE/qemu-install --target-list=riscv64-linux-user --disable-system
-          make -j$(nproc)
-          make install
-
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.target }}
-
-      - name: Configure ccache
-        run: |
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-
-      - name: build OpenBLAS
-        run: |
-            wget ${xuetie_toolchain}/${toolchain_file_name}
-            tar -xvf ${toolchain_file_name} -C /opt
-            export PATH="/opt/Xuantie-900-gcc-linux-5.10.4-glibc-x86_64-V2.8.0/bin:$PATH"
-
-            make CC='ccache ${{ matrix.triple }}-gcc -static' FC='ccache ${{ matrix.triple }}-gfortran -static' ${{ matrix.opts }} HOSTCC='ccache gcc' -j$(nproc)
-
-      - name: test
-        run: |
-          run_with_retry() {
-              local cmd="$1"
-              local time_out="${2:-10}"
-              local retries="${3:-10}"
-              local timeout_step="${4:-5}"
-              local attempt=0
-
-              for ((i=1; i<=retries; i++)); do
-                  attempt=$((i))
-                  if timeout -s 12  --preserve-status $time_out $cmd; then
-                      echo "Command succeeded on attempt $i."
-                      return 0
-                  else
-                      local exit_code=$?
-                      if [ $exit_code -eq 140 ]; then
-                          echo "Attempt $i timed out (retrying...)"
-                          time_out=$((time_out + timeout_step))
-                      else
-                          echo "Attempt $i failed with exit code $exit_code. Aborting workflow."
-                          exit $exit_code
-                      fi
-                  fi
-              done
-              echo "All $retries attempts failed, giving up."
-              echo "Final failure was due to timeout."
-              echo "Aborting workflow."
-              exit $exit_code
-          }
-          export PATH=$GITHUB_WORKSPACE/qemu-install/bin:$PATH
-          which qemu-riscv64
-          export QEMU_BIN=$(which qemu-riscv64)
-          run_with_retry "$QEMU_BIN ./utest/openblas_utest" 120 2 30
-          run_with_retry "$QEMU_BIN ./utest/openblas_utest_ext"
-
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xscblat1
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xdcblat1
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xccblat1
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xzcblat1
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xscblat2 < ./ctest/sin2
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xdcblat2 < ./ctest/din2
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xccblat2 < ./ctest/cin2
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xzcblat2 < ./ctest/zin2
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xscblat3 < ./ctest/sin3
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xdcblat3 < ./ctest/din3
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xccblat3 < ./ctest/cin3
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./ctest/xzcblat3 < ./ctest/zin3
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/sblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/dblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/cblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/zblat1
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/sblat1
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/dblat1
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/cblat1
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/zblat1
-          rm -f ./test/?BLAT2.SUMM
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/sblat2 < ./test/sblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/dblat2 < ./test/dblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/cblat2 < ./test/cblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/zblat2 < ./test/zblat2.dat
-          rm -f ./test/?BLAT2.SUMM
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/sblat2 < ./test/sblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/dblat2 < ./test/dblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/cblat2 < ./test/cblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/zblat2 < ./test/zblat2.dat
-          rm -f ./test/?BLAT3.SUMM
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/sblat3 < ./test/sblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/dblat3 < ./test/dblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/cblat3 < ./test/cblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-riscv64 ./test/zblat3 < ./test/zblat3.dat
-          rm -f ./test/?BLAT3.SUMM
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/sblat3 < ./test/sblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/dblat3 < ./test/dblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/cblat3 < ./test/cblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-riscv64 ./test/zblat3 < ./test/zblat3.dat

.github/workflows/codspeed-bench.yml

@@ -1,166 +0,0 @@
-name: Run codspeed benchmarks
-
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  benchmarks:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    strategy:
-      fail-fast: false
-      matrix:
-        os: [ubuntu-22.04]
-        fortran: [gfortran]
-        build: [make]
-        pyver: ["3.12"]
-    runs-on: ${{ matrix.os }}
-    steps:
-      - uses: actions/checkout@v6
-      - uses: actions/setup-python@v6
-        with:
-            python-version: ${{ matrix.pyver }}
-
-      - name: Print system information
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            cat /proc/cpuinfo
-          fi
-
-      - name: Install Dependencies
-        run: |
-          if [ "$RUNNER_OS" == "Linux" ]; then
-            sudo apt-get update
-            sudo apt-get install -y gfortran cmake ccache libtinfo5
-          else
-            echo "::error::$RUNNER_OS not supported"
-            exit 1
-          fi
-
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          # We include the commit sha in the cache key, as new cache entries are
-          # only created if there is no existing entry for the key yet.
-          # GNU make and cmake call the compilers differently. It looks like
-          # that causes the cache to mismatch. Keep the ccache for both build
-          # tools separate to avoid polluting each other.
-          key: ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}-${{ github.ref }}-${{ github.sha }}
-          # Restore a matching ccache cache entry. Prefer same branch and same Fortran compiler.
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.build }}-${{ matrix.fortran }}
-            ccache-${{ runner.os }}-${{ matrix.build }}
-
-      - name: Write out the .pc
-        run: |
-             cd benchmark/pybench
-             cat > openblas.pc << EOF
-             libdir=${{ github.workspace }}
-             includedir= ${{ github.workspace }}
-             openblas_config= OpenBLAS 0.3.27 DYNAMIC_ARCH NO_AFFINITY Haswell MAX_THREADS=64
-             version=0.0.99
-             extralib=-lm -lpthread -lgfortran -lquadmath -L${{ github.workspace }} -lopenblas
-             Name: openblas
-             Description: OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version
-             Version: ${version}
-             URL: https://github.com/xianyi/OpenBLAS
-             Libs: ${{ github.workspace }}/libopenblas.so -Wl,-rpath,${{ github.workspace }}
-             Libs.private: -lm -lpthread -lgfortran -lquadmath -L${{ github.workspace }} -lopenblas
-             Cflags: -I${{ github.workspace}}
-             EOF
-             cat openblas.pc
-
-      - name: Configure ccache
-        run: |
-          if [ "${{ matrix.build }}" = "make" ]; then
-            # Add ccache to path
-            if [ "$RUNNER_OS" = "Linux" ]; then
-              echo "/usr/lib/ccache" >> $GITHUB_PATH
-            elif [ "$RUNNER_OS" = "macOS" ]; then
-              echo "$(brew --prefix)/opt/ccache/libexec" >> $GITHUB_PATH
-            else
-              echo "::error::$RUNNER_OS not supported"
-              exit 1
-            fi
-          fi
-          # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota (5 GB).
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-
-      - name: Build OpenBLAS
-        run: |
-          case "${{ matrix.build }}" in
-            "make")
-              make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=0 FC="ccache ${{ matrix.fortran }}"
-              ;;
-            "cmake")
-              mkdir build && cd build
-              cmake -DDYNAMIC_ARCH=1 \
-                    -DNOFORTRAN=0 \
-                    -DBUILD_WITHOUT_LAPACK=0 \
-                    -DCMAKE_VERBOSE_MAKEFILE=ON \
-                    -DCMAKE_BUILD_TYPE=Release \
-                    -DCMAKE_Fortran_COMPILER=${{ matrix.fortran }} \
-                    -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-                    -DCMAKE_Fortran_COMPILER_LAUNCHER=ccache \
-                    ..
-              cmake --build .
-              ;;
-            *)
-              echo "::error::Configuration not supported"
-              exit 1
-              ;;
-          esac
-
-      - name: Show ccache status
-        continue-on-error: true
-        run: ccache -s
-
-      - name: Install benchmark dependencies
-        run: pip install meson ninja numpy pytest pytest-codspeed --user
-
-      - name: Build the wrapper
-        run: |
-          cd benchmark/pybench
-          export PKG_CONFIG_PATH=$PWD
-          meson setup build  --prefix=$PWD/build-install
-          meson install -C build
-          #
-          # sanity check
-          cd build/openblas_wrap
-          python -c'import _flapack; print(dir(_flapack))'
-
-      - name: Run benchmarks under pytest-benchmark
-        run: |
-          cd benchmark/pybench
-          pip install pytest-benchmark
-          export PYTHONPATH=$PWD/build-install/lib/python${{matrix.pyver}}/site-packages/
-          OPENBLAS_NUM_THREADS=1 pytest benchmarks/bench_blas.py -k 'gesdd'
-
-      - name: Run benchmarks
-        uses: CodSpeedHQ/action@v4
-        with:
-          mode: simulation
-          token: ${{ secrets.CODSPEED_TOKEN }}
-          run: |
-            cd benchmark/pybench
-            export PYTHONPATH=$PWD/build-install/lib/python${{matrix.pyver}}/site-packages/
-            OPENBLAS_NUM_THREADS=1 pytest benchmarks/bench_blas.py --codspeed
-

.github/workflows/docs.yml

@@ -1,48 +0,0 @@
-name: Publish docs via GitHub Pages
-
-on:
-  push:
-    branches:
-      - develop
-    paths:
-      - 'docs/**'
-      - 'mkdocs.yml'
-      - '.github/workflows/docs.yml'
-  pull_request:
-    branches:
-      - develop
-    paths:
-      - 'docs/**'
-      - 'mkdocs.yml'
-      - '.github/workflows/docs.yml'
-
-jobs:
-  build:
-    name: Deploy docs
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-latest
-    steps:
-      - uses: actions/checkout@v6
-        with:
-          fetch-depth: 0
-
-      - uses: actions/setup-python@v6
-        with:
-          python-version: "3.10"
-
-      - name: Install MkDocs and doc theme packages
-        run: pip install mkdocs mkdocs-material mkdocs-git-revision-date-localized-plugin mkdocs-mermaid2-plugin
-
-      - name: Build docs site
-        run: mkdocs build
-
-      # mkdocs gh-deploy command only builds to the top-level, hence deploying
-      # with this action instead.
-      # Deploys to http://www.openmathlib.org/OpenBLAS/docs/
-      - name: Deploy docs
-        uses: peaceiris/actions-gh-pages@4f9cc6602d3f66b9c108549d475ec49e8ef4d45e # v4.0.0
-        if: ${{ github.ref == 'refs/heads/develop' }}
-        with:
-          github_token: ${{ secrets.GITHUB_TOKEN }}
-          publish_dir: ./site
-          destination_dir: docs/

.github/workflows/dynamic_arch.yml

@@ -1,48 +1,31 @@
 name: continuous build
 
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  workflow_dispatch:
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
+on: [push, pull_request]
 
 jobs:
   build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS' || github.event_name == 'workflow_dispatch'"
     runs-on: ${{ matrix.os }}
-
     strategy:
       fail-fast: false
       matrix:
-        os: [ubuntu-latest, macos-latest, ubuntu-24.04-arm]
-        cc: [gcc, clang, clang-21]
+        os: [ubuntu-latest, macos-latest]
         fortran: [gfortran, flang]
         build: [cmake, make]
-        exclude:
-          - os: macos-latest
-            cc: gcc
-          - os: macos-latest
-            cc: clang-21
-          - os: macos-latest
-            fortran: flang
-          - os: ubuntu-24.04-arm
-            fortran: flang
-
     steps:
       - name: Checkout repository
-        uses: actions/checkout@v6
+        uses: actions/checkout@v2
+
+      - name: Compilation cache
+        uses: actions/cache@v2
+        with:
+          path: ~/.ccache
+          # We include the commit sha in the cache key, as new cache entries are
+          # only created if there is no existing entry for the key yet.
+          key: ${{ runner.os }}-ccache-${{ github.sha }}
+          # Restore any ccache cache entry, if none for
+          # ${{ runner.os }}-ccache-${{ github.sha }} exists
+          restore-keys: |
+            ${{ runner.os }}-ccache-
 
       - name: Print system information
         run: |
@@ -51,688 +34,70 @@ jobs:
           elif [ "$RUNNER_OS" == "macOS" ]; then
             sysctl -a | grep machdep.cpu
           else
-            echo "::error::$RUNNER_OS not supported"
+            echo "$RUNNER_OS not supported"
             exit 1
           fi
 
       - name: Install Dependencies
         run: |
           if [ "$RUNNER_OS" == "Linux" ]; then
-            cat << EOF | sudo tee -a /etc/apt/apt.conf.d/01norecommend
-          APT::Install-Recommends "0";
-          APT::Install-Suggests "0";
-          EOF
-            sudo apt-get update
-            sudo apt-get install -y ccache
-            if [ "${{ matrix.cc }}" == "clang-21" ]; then
-                wget https://apt.llvm.org/llvm.sh
-                chmod +x llvm.sh
-                sudo ./llvm.sh 21
-            fi
-            if [ "${{ matrix.fortran }}" == "flang" ]; then
-              wget http://security.ubuntu.com/ubuntu/pool/universe/n/ncurses/libtinfo5_6.3-2ubuntu0.2_amd64.deb
-              sudo apt install ./libtinfo5_6.3-2ubuntu0.2_amd64.deb
-            else
-              sudo apt-get install -y ${{ matrix.fortran }}
-            fi
+            sudo apt-get install -y gfortran cmake ccache
           elif [ "$RUNNER_OS" == "macOS" ]; then
-            # It looks like "gfortran" isn't working correctly unless "gcc" is re-installed.
-            brew reinstall gcc
-            brew install coreutils ccache
+            brew install coreutils cmake ccache
           else
-            echo "::error::$RUNNER_OS not supported"
+            echo "$RUNNER_OS not supported"
+            exit 1
+          fi
+          ccache -M 300M  # Limit the ccache size; Github's overall cache limit is 5GB
+
+      - name: gfortran build
+        if: matrix.build == 'make' && matrix.fortran == 'gfortran'
+        run: |
+          if [ "$RUNNER_OS" == "Linux" ]; then
+            export PATH="/usr/lib/ccache:${PATH}"
+          elif [ "$RUNNER_OS" == "macOS" ]; then
+            export PATH="$(brew --prefix)/opt/ccache/libexec:${PATH}"
+          else
+            echo "$RUNNER_OS not supported"
             exit 1
           fi
 
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          # We include the commit sha in the cache key, as new cache entries are
-          # only created if there is no existing entry for the key yet.
-          # GNU make and cmake call the compilers differently. It looks like
-          # that causes the cache to mismatch. Keep the ccache for both build
-          # tools separate to avoid polluting each other.
-          key: ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.build }}-${{ matrix.cc }}-${{ matrix.fortran }}-${{ github.ref }}-${{ github.sha }}
-          # Restore a matching ccache cache entry. Prefer same branch and same Fortran compiler.
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.build }}-${{ matrix.cc }}-${{ matrix.fortran }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.build }}-${{ matrix.cc }}-${{ matrix.fortran }}
-            ccache-${{ runner.os }}-${{ runner.arch }}-${{ matrix.build }}-${{ matrix.cc }}
+          make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=0
 
-      - name: Configure ccache
+      - name: flang build
+        if: matrix.build == 'make' && matrix.fortran == 'flang'
         run: |
-          if [ "${{ matrix.build }}" = "make" ]; then
-            # Add ccache to path
-            if [ "$RUNNER_OS" = "Linux" ]; then
-              echo "/usr/lib/ccache" >> $GITHUB_PATH
-            elif [ "$RUNNER_OS" = "macOS" ]; then
-              echo "$(brew --prefix)/opt/ccache/libexec" >> $GITHUB_PATH
-            else
-              echo "::error::$RUNNER_OS not supported"
-              exit 1
-            fi
+          if [ "$RUNNER_OS" == "Linux" ]; then
+            export PATH="/usr/lib/ccache:${PATH}"
+          elif [ "$RUNNER_OS" == "macOS" ]; then
+            exit 0
+          else
+            echo "$RUNNER_OS not supported"
+            exit 1
           fi
-          # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota (5 GB).
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
 
-      - name: Add gfortran runtime to link path
-        if: matrix.build == 'make' && runner.os == 'macOS'
-        run: |
-          GFORTRAN_LIBDIR=$(gfortran -print-file-name=libgfortran.dylib | xargs dirname)
-          echo "Using gfortran runtime in $GFORTRAN_LIBDIR"
-          # Preserve whatever LDFLAGS may already contain
-          echo "LDFLAGS=${LDFLAGS:+$LDFLAGS }-L$GFORTRAN_LIBDIR" >> "$GITHUB_ENV"
+          cd /usr/
+          sudo wget -nv https://github.com/flang-compiler/flang/releases/download/flang_20190329/flang-20190329-x86-70.tgz
+          sudo tar xf flang-20190329-x86-70.tgz
+          sudo rm flang-20190329-x86-70.tgz
+          cd -
 
-      - name: Build OpenBLAS
+          make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=0 FC=flang
+
+
+      - name: CMake gfortran build
+        if: matrix.build == 'cmake' && matrix.fortran == 'gfortran'
         run: |
-          if [ "${{ matrix.fortran }}" = "flang" ]; then
-            # download and install classic flang
-            cd /usr/
-            sudo wget -nv https://github.com/flang-compiler/flang/releases/download/flang_20190329/flang-20190329-x86-70.tgz
-            sudo tar xf flang-20190329-x86-70.tgz
-            sudo rm flang-20190329-x86-70.tgz
-            cd -
+          if [ "$RUNNER_OS" == "Linux" ]; then
+            export PATH="/usr/lib/ccache:${PATH}"
+          elif [ "$RUNNER_OS" == "macOS" ]; then
+            export PATH="$(brew --prefix)/opt/ccache/libexec:${PATH}"
+          else
+            echo "$RUNNER_OS not supported"
+            exit 1
           fi
-          case "${{ matrix.build }}" in
-            "make")
-              make -j$(nproc) DYNAMIC_ARCH=1 USE_OPENMP=0 CC="ccache ${{ matrix.cc }}" FC="ccache ${{ matrix.fortran }}"
-              ;;
-            "cmake")
-              mkdir build && cd build
-              cmake -DDYNAMIC_ARCH=1 \
-                    -DNOFORTRAN=0 \
-                    -DBUILD_WITHOUT_LAPACK=0 \
-                    -DCMAKE_VERBOSE_MAKEFILE=ON \
-                    -DCMAKE_BUILD_TYPE=Release \
-                    -DCMAKE_C_COMPILER=${{ matrix.cc }} \
-                    -DCMAKE_Fortran_COMPILER=${{ matrix.fortran }} \
-                    -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-                    -DCMAKE_Fortran_COMPILER_LAUNCHER=ccache \
-                    ..
-              cmake --build .
-              ;;
-            *)
-              echo "::error::Configuration not supported"
-              exit 1
-              ;;
-          esac
 
-      - name: Show ccache status
-        continue-on-error: true
-        run: ccache -s
-
-      - name: Run tests
-        timeout-minutes: 60
-        run: |
-          case "${{ matrix.build }}" in
-            "make")
-              MAKE_FLAGS='DYNAMIC_ARCH=1 USE_OPENMP=0'
-              echo "::group::Tests in 'test' directory"
-              make -C test $MAKE_FLAGS CC="ccache ${{ matrix.cc }}" FC="ccache ${{ matrix.fortran }}"
-              echo "::endgroup::"
-              echo "::group::Tests in 'ctest' directory"
-              make -C ctest $MAKE_FLAGS CC="ccache ${{ matrix.cc }}" FC="ccache ${{ matrix.fortran }}"
-              echo "::endgroup::"
-              echo "::group::Tests in 'utest' directory"
-              make -C utest $MAKE_FLAGS CC="ccache ${{ matrix.cc }}" FC="ccache ${{ matrix.fortran }}"
-              echo "::endgroup::"
-              ;;
-            "cmake")
-              cd build && ctest
-              ;;
-            *)
-              echo "::error::Configuration not supported"
-              exit 1
-              ;;
-          esac
-
-
-  msys2:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: windows-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        msystem: [UCRT64, MINGW32, CLANG64]
-        idx: [int32, int64]
-        build-type: [Release]
-        include:
-          - msystem: UCRT64
-            idx: int32
-            target-prefix: mingw-w64-ucrt-x86_64
-            fc-pkg: mingw-w64-ucrt-x86_64-fc
-          - msystem: MINGW32
-            idx: int32
-            target-prefix: mingw-w64-i686
-            fc-pkg:
-          - msystem: CLANG64
-            idx: int32
-            target-prefix: mingw-w64-clang-x86_64
-            fc-pkg: mingw-w64-clang-x86_64-fc
-          - msystem: UCRT64
-            idx: int64
-            idx64-flags: -DBINARY=64 -DINTERFACE64=1
-            target-prefix: mingw-w64-ucrt-x86_64
-            fc-pkg: mingw-w64-ucrt-x86_64-fc
-          - msystem: CLANG64
-            idx: int64
-            idx64-flags: -DBINARY=64 -DINTERFACE64=1
-            target-prefix: mingw-w64-clang-x86_64
-            fc-pkg: mingw-w64-clang-x86_64-fc
-          - msystem: UCRT64
-            idx: int32
-            target-prefix: mingw-w64-ucrt-x86_64
-            fc-pkg: mingw-w64-ucrt-x86_64-fc
-            build-type: None
-        exclude:
-          - msystem: MINGW32
-            idx: int64
-
-    defaults:
-      run:
-        # Use MSYS2 bash as default shell
-        shell: msys2 {0}
-
-    env:
-      CHERE_INVOKING: 1
-
-    steps:
-      - name: Get CPU name
-        shell: pwsh
-        run : |
-          Get-CIMInstance -Class Win32_Processor | Select-Object -Property Name
-
-      - name: Install build dependencies
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: ${{ matrix.msystem }}
-          update: true
-          release: false  # Use pre-installed version
-          install: >-
-            base-devel
-            ${{ matrix.target-prefix }}-cc
-            ${{ matrix.fc-pkg }}
-            ${{ matrix.target-prefix }}-cmake
-            ${{ matrix.target-prefix }}-ninja
-            ${{ matrix.target-prefix }}-ccache
-
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Prepare ccache
-        # Get cache location of ccache
-        # Create key that is used in action/cache/restore and action/cache/save steps
-        id: ccache-prepare
-        run: |
-          echo "ccachedir=$(cygpath -m $(ccache -k cache_dir))" >> $GITHUB_OUTPUT
-          # We include the commit sha in the cache key, as new cache entries are
-          # only created if there is no existing entry for the key yet.
-          echo "key=ccache-msys2-${{ matrix.msystem }}-${{ matrix.idx }}-${{ matrix.build-type }}-${{ github.ref }}-${{ github.sha }}" >> $GITHUB_OUTPUT
-
-      - name: Restore ccache
-        uses: actions/cache/restore@v5
-        with:
-          path: ${{ steps.ccache-prepare.outputs.ccachedir }}
-          key: ${{ steps.ccache-prepare.outputs.key }}
-          # Restore a matching ccache cache entry. Prefer same branch.
-          restore-keys: |
-            ccache-msys2-${{ matrix.msystem }}-${{ matrix.idx }}-${{ matrix.build-type }}-${{ github.ref }}
-            ccache-msys2-${{ matrix.msystem }}-${{ matrix.idx }}-${{ matrix.build-type }}
-
-      - name: Configure ccache
-        # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota.
-        run: |
-          which ccache
-          test -d ${{ steps.ccache-prepare.outputs.ccachedir }} || mkdir -p ${{ steps.ccache-prepare.outputs.ccachedir }}
-          echo "max_size = 250M" > ${{ steps.ccache-prepare.outputs.ccachedir }}/ccache.conf
-          echo "compression = true" >> ${{ steps.ccache-prepare.outputs.ccachedir }}/ccache.conf
-          ccache -p
-          ccache -s
-          echo $HOME
-          cygpath -w $HOME
-
-      - name: Configure OpenBLAS
-        run: |
-          mkdir build && cd build
-          cmake -DCMAKE_BUILD_TYPE=${{ matrix.build-type }} \
-                -DBUILD_SHARED_LIBS=ON \
-                -DBUILD_STATIC_LIBS=ON \
-                -DDYNAMIC_ARCH=ON \
-                -DUSE_THREAD=ON \
-                -DNUM_THREADS=64 \
-                -DTARGET=CORE2 \
-                ${{ matrix.idx64-flags }} \
-                -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-                -DCMAKE_Fortran_COMPILER_LAUNCHER=ccache \
-                ..
-
-      - name: Build OpenBLAS
-        run: cd build && cmake --build .
-
-      - name: Show ccache status
-        continue-on-error: true
-        run: ccache -s
-
-      - name: Save ccache
-        # Save the cache after we are done (successfully) building
-        uses: actions/cache/save@v5
-        with:
-          path: ${{ steps.ccache-prepare.outputs.ccachedir }}
-          key: ${{ steps.ccache-prepare.outputs.key }}
-
-      - name: Run tests
-        id: run-ctest
-        timeout-minutes: 60
-        run: cd build && ctest
-
-      - name: Re-run tests
-        if: always() && (steps.run-ctest.outcome == 'failure')
-        timeout-minutes: 60
-        run: |
+          mkdir build
           cd build
-          echo "::group::Re-run ctest"
-          ctest --rerun-failed --output-on-failure || true
-          echo "::endgroup::"
-          echo "::group::Log from these tests"
-          [ ! -f Testing/Temporary/LastTest.log ] || cat Testing/Temporary/LastTest.log
-          echo "::endgroup::"
-
-
-  linux_thread_stress:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    name: ${{ matrix.check-name }}
-    runs-on: ubuntu-latest
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - backend: pthread
-            check-name: "linux_thread_stress (pthread)"
-          - backend: openmp
-            check-name: "linux_thread_stress (openmp)"
-          - backend: tsan
-            check-name: linux_thread_sanitizer
-          - backend: tsan-openmp
-            check-name: linux_thread_sanitizer_openmp
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install Dependencies
-        run: |
-          cat << EOF | sudo tee -a /etc/apt/apt.conf.d/01norecommend
-          APT::Install-Recommends "0";
-          APT::Install-Suggests "0";
-          EOF
-          sudo apt-get update
-          sudo apt-get install -y ccache cmake ninja-build
-          case "${{ matrix.backend }}" in
-            tsan|tsan-openmp) sudo apt-get install -y clang llvm ;;
-          esac
-          if [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
-            sudo apt-get install -y libomp-dev
-          fi
-
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          key: ccache-${{ runner.os }}-thread-${{ matrix.backend }}-${{ github.ref }}-${{ github.sha }}
-          restore-keys: |
-            ccache-${{ runner.os }}-thread-${{ matrix.backend }}-${{ github.ref }}
-            ccache-${{ runner.os }}-thread-${{ matrix.backend }}
-
-      - name: Configure ccache
-        # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota.
-        run: |
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 250M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-
-      - name: Configure OpenBLAS
-        run: |
-          mkdir build && cd build
-          build_type=Release
-          c_compiler=gcc
-          cxx_compiler=g++
-          dynamic_arch=ON
-          use_openmp=OFF
-          cpp_thread_safety_use_openmp=ON
-          dgemm_args="512;12;4"
-          dgemm_mixed_args="524288;16;20"
-          dgemv_args="512;12;4"
-          sanitizer_flags=
-          if [ "${{ matrix.backend }}" = "openmp" ]; then
-            use_openmp=ON
-          elif [ "${{ matrix.backend }}" = "tsan" ] || [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
-            build_type=RelWithDebInfo
-            c_compiler=clang
-            cxx_compiler=clang++
-            dynamic_arch=OFF
-            cpp_thread_safety_use_openmp=OFF
-            dgemm_args="64;4;1"
-            dgemm_mixed_args="131072;8;10"
-            dgemv_args="64;4;1"
-            sanitizer_flags="-fsanitize=thread -g -O1 -fno-omit-frame-pointer"
-            if [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
-              use_openmp=ON
-              cpp_thread_safety_use_openmp=ON
-            fi
-          fi
-          cmake_args=(
-            -G Ninja
-            "-DCMAKE_BUILD_TYPE=$build_type"
-            "-DCMAKE_C_COMPILER=$c_compiler"
-            "-DCMAKE_CXX_COMPILER=$cxx_compiler"
-            -DBUILD_SHARED_LIBS=ON
-            -DBUILD_STATIC_LIBS=OFF
-            -DBUILD_WITHOUT_LAPACK=ON
-            -DBUILD_SINGLE=OFF
-            -DBUILD_DOUBLE=ON
-            -DBUILD_COMPLEX=OFF
-            -DBUILD_COMPLEX16=OFF
-            "-DDYNAMIC_ARCH=$dynamic_arch"
-            -DNOFORTRAN=ON
-            -DUSE_THREAD=ON
-            "-DUSE_OPENMP=$use_openmp"
-            -DNUM_THREADS=32
-            -DNUM_PARALLEL=2
-            -DTARGET=CORE2
-            -DCPP_THREAD_SAFETY_TEST=ON
-            "-DCPP_THREAD_SAFETY_USE_OPENMP=$cpp_thread_safety_use_openmp"
-            "-DCPP_THREAD_SAFETY_DGEMM_ARGS=$dgemm_args"
-            "-DCPP_THREAD_SAFETY_DGEMM_MIXED_ARGS=$dgemm_mixed_args"
-            "-DCPP_THREAD_SAFETY_DGEMV_ARGS=$dgemv_args"
-            -DCMAKE_C_COMPILER_LAUNCHER=ccache
-            -DCMAKE_CXX_COMPILER_LAUNCHER=ccache
-          )
-          if [ "${{ matrix.backend }}" = "tsan" ] || [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
-            cmake_args+=(
-              "-DCMAKE_C_FLAGS=$sanitizer_flags"
-              "-DCMAKE_CXX_FLAGS=$sanitizer_flags"
-              -DCMAKE_SHARED_LINKER_FLAGS=-fsanitize=thread
-              -DCMAKE_EXE_LINKER_FLAGS=-fsanitize=thread
-            )
-          fi
-          cmake "${cmake_args[@]}" ..
-
-      - name: Build OpenBLAS
-        run: |
-          cd build
-          cmake --build . --target dgemm_thread_safety dgemm_thread_safety_mixed dgemv_thread_safety
-
-      - name: Show ccache status
-        continue-on-error: true
-        run: ccache -s
-
-      - name: Run thread stress tests
-        timeout-minutes: 30
-        run: |
-          cd build
-          if [ "${{ matrix.backend }}" = "tsan" ] || [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
-            export LLVM_SYMBOLIZER_PATH=/usr/bin/llvm-symbolizer
-            export TSAN_OPTIONS=halt_on_error=1:exitcode=66:second_deadlock_stack=1
-          fi
-          if [ "${{ matrix.backend }}" = "tsan-openmp" ]; then
-            # Load Archer (the OMPT tool from Ubuntu's libomp-dev) so TSan
-            # understands libomp's barriers instead of flagging them as false positives. The OpenMP runtime will load this tool automatically if OMP_TOOL_LIBRARIES is set.
-            archer=$(clang -print-file-name=libarcher.so)
-            [ -f "$archer" ] || archer=$(find /usr/lib/llvm-* -name libarcher.so 2>/dev/null | head -1)
-            if [ ! -f "$archer" ]; then
-              echo "::error::libarcher.so not found (expected from libomp-dev)"
-              exit 1
-            fi
-            echo "Using distro Archer: $archer"
-            export OMP_TOOL_LIBRARIES="$archer"
-            export TSAN_OPTIONS="$TSAN_OPTIONS:ignore_noninstrumented_modules=1"
-          fi
-          if [ "${{ matrix.backend }}" != "tsan" ]; then
-            export OMP_NUM_THREADS=16
-          fi
-          export OPENBLAS_NUM_THREADS=8
-          ctest -R 'dgemm_thread_safety|dgemm_thread_safety_mixed|dgemv_thread_safety' --output-on-failure
-
-
-  msys2_thread_stress:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: windows-latest
-
-    defaults:
-      run:
-        shell: msys2 {0}
-
-    env:
-      CHERE_INVOKING: 1
-
-    steps:
-      - name: Get CPU name
-        shell: pwsh
-        run : |
-          Get-CIMInstance -Class Win32_Processor | Select-Object -Property Name
-
-      - name: Install build dependencies
-        uses: msys2/setup-msys2@v2
-        with:
-          msystem: UCRT64
-          update: true
-          release: false  # Use pre-installed version
-          install: >-
-            base-devel
-            mingw-w64-ucrt-x86_64-cc
-            mingw-w64-ucrt-x86_64-cmake
-            mingw-w64-ucrt-x86_64-ninja
-            mingw-w64-ucrt-x86_64-ccache
-
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Prepare ccache
-        # Get cache location of ccache
-        # Create key that is used in action/cache/restore and action/cache/save steps
-        id: ccache-prepare
-        run: |
-          echo "ccachedir=$(cygpath -m $(ccache -k cache_dir))" >> $GITHUB_OUTPUT
-          # We include the commit sha in the cache key, as new cache entries are
-          # only created if there is no existing entry for the key yet.
-          echo "key=ccache-msys2-thread-stress-${{ github.ref }}-${{ github.sha }}" >> $GITHUB_OUTPUT
-
-      - name: Restore ccache
-        uses: actions/cache/restore@v5
-        with:
-          path: ${{ steps.ccache-prepare.outputs.ccachedir }}
-          key: ${{ steps.ccache-prepare.outputs.key }}
-          # Restore a matching ccache cache entry. Prefer same branch.
-          restore-keys: |
-            ccache-msys2-thread-stress-${{ github.ref }}
-            ccache-msys2-thread-stress
-
-      - name: Configure ccache
-        # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota.
-        run: |
-          which ccache
-          test -d ${{ steps.ccache-prepare.outputs.ccachedir }} || mkdir -p ${{ steps.ccache-prepare.outputs.ccachedir }}
-          echo "max_size = 250M" > ${{ steps.ccache-prepare.outputs.ccachedir }}/ccache.conf
-          echo "compression = true" >> ${{ steps.ccache-prepare.outputs.ccachedir }}/ccache.conf
-          ccache -p
-          ccache -s
-
-      - name: Configure OpenBLAS
-        run: |
-          mkdir build && cd build
-          cmake -G Ninja \
-                -DCMAKE_BUILD_TYPE=Release \
-                -DBUILD_SHARED_LIBS=ON \
-                -DBUILD_STATIC_LIBS=OFF \
-                -DBUILD_WITHOUT_LAPACK=ON \
-                -DBUILD_SINGLE=OFF \
-                -DBUILD_DOUBLE=ON \
-                -DBUILD_COMPLEX=OFF \
-                -DBUILD_COMPLEX16=OFF \
-                -DDYNAMIC_ARCH=OFF \
-                -DNOFORTRAN=ON \
-                -DUSE_THREAD=ON \
-                -DUSE_OPENMP=OFF \
-                -DNUM_THREADS=32 \
-                -DTARGET=CORE2 \
-                -DCPP_THREAD_SAFETY_TEST=ON \
-                -DCPP_THREAD_SAFETY_DGEMM_ARGS="384;8;4" \
-                -DCPP_THREAD_SAFETY_DGEMM_MIXED_ARGS="524288;16;20" \
-                -DCPP_THREAD_SAFETY_DGEMV_ARGS="384;8;4" \
-                -DCMAKE_C_COMPILER_LAUNCHER=ccache \
-                -DCMAKE_CXX_COMPILER_LAUNCHER=ccache \
-                ..
-
-      - name: Build OpenBLAS
-        run: |
-          cd build
-          cmake --build . --target dgemm_thread_safety dgemm_thread_safety_mixed dgemm_thread_safety_shutdown dgemv_thread_safety
-
-      - name: Show ccache status
-        continue-on-error: true
-        run: ccache -s
-
-      - name: Save ccache
-        # Save the cache after we are done (successfully) building
-        uses: actions/cache/save@v5
-        with:
-          path: ${{ steps.ccache-prepare.outputs.ccachedir }}
-          key: ${{ steps.ccache-prepare.outputs.key }}
-
-      - name: Run thread stress tests
-        timeout-minutes: 30
-        run: |
-          cd build
-          export PATH="$PWD/lib:$PATH"
-          OPENBLAS_NUM_THREADS=8 OMP_NUM_THREADS=16 ctest -R 'dgemm_thread_safety|dgemm_thread_safety_mixed|dgemm_thread_safety_shutdown|dgemv_thread_safety' --output-on-failure
-
-
-  cross_build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-22.04
-
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - target: mips64el
-            triple: mips64el-linux-gnuabi64
-            opts: DYNAMIC_ARCH=1 TARGET=GENERIC
-          - target: riscv64
-            triple: riscv64-linux-gnu
-            opts: TARGET=RISCV64_GENERIC
-          - target: mipsel
-            triple: mipsel-linux-gnu
-            opts: TARGET=MIPS1004K
-          - target: alpha
-            triple: alpha-linux-gnu
-            opts: TARGET=EV4
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install Dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y ccache gcc-${{ matrix.triple }} gfortran-${{ matrix.triple }} libgomp1-${{ matrix.target }}-cross
-
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.target }}
-
-      - name: Configure ccache
-        run: |
-          # Limit the maximum size and switch on compression to avoid exceeding the total disk or cache quota (5 GB).
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-
-
-      - name: Build OpenBLAS
-        run: |
-          make -j$(nproc) HOSTCC="ccache gcc" CC="ccache ${{ matrix.triple }}-gcc" FC="ccache ${{ matrix.triple }}-gfortran" ARCH=${{ matrix.target }} ${{ matrix.opts }}
-
-  neoverse_build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-24.04-arm
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install Dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc gfortran make
-
-      - name: Build OpenBLAS
-        run: |
-          make -j${nproc}
-          make -j${nproc} lapack-test
-
-  neoverse_n1_build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-24.04-arm
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install Dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc gfortran make
-
-      - name: Build OpenBLAS
-        run: |
-          make -j${nproc} TARGET=NEOVERSEN1
-          make -j${nproc} TARGET=NEOVERSEN1 lapack-test
-
-  neoverse_n1_omp_build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-24.04-arm
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install Dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc gfortran make
-
-      - name: Build OpenBLAS
-        run: |
-          make -j${nproc} TARGET=NEOVERSEN1 USE_OPENMP=1
-
-  neoverse_n1_ilp64_build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-24.04-arm
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install Dependencies
-        run: |
-          sudo apt-get update
-          sudo apt-get install -y gcc gfortran make
-
-      - name: Build OpenBLAS
-        run: |
-          make -j${nproc} TARGET=NEOVERSEN1 INTERFACE64=1
-          make -j${nproc} TARGET=NEOVERSEN1 INTERFACE64=1 lapack-test
+          cmake -DDYNAMIC_ARCH=1 -DNOFORTRAN=0 -DBUILD_WITHOUT_LAPACK=0  -DCMAKE_VERBOSE_MAKEFILE=ON -DCMAKE_BUILD_TYPE=Release ..
+          make -j$(nproc)

.github/workflows/freebsd.yml

@@ -1,63 +0,0 @@
-name: freebsd
-
-on:
-  push:
-    branches:
-      - develop
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    branches:
-      - develop
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  bsd-x86:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-latest
-    steps:
-     - name: checkout
-       uses: actions/checkout@v6
-     
-     - name: build
-       id: freebsd_x86_64
-       uses: vmactions/freebsd-vm@v1
-       with:
-        usesh: true
-        prepare: |
-
-        run: |
-          freebsd-version
-          sysctl hw.ncpu
-          pkg install -y gmake gcc15
-          gmake CC=gcc15 FC=gfortran15
-          
-  bsd-aarch64:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-latest
-    steps:
-     - name: checkout
-       uses: actions/checkout@v6
-     
-     - name: build
-       id: freebsd_arm64
-       uses: vmactions/freebsd-vm@v1
-       with:
-        arch: aarch64
-        usesh: true
-        run: |
-          freebsd-version
-          sysctl hw.ncpu
-          pkg install -y gmake gcc15
-          gmake CC=gcc15 FC=gfortran15
-          

.github/workflows/harmonyos.yml

@@ -1,45 +0,0 @@
-name: harmonyos
-
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-latest
-    env:
-      OHOS_NDK_CMAKE: $GITHUB_WORKSPACE/ohos-sdk/linux/native/build-tools/cmake/bin/cmake
-      COMMON_CMAKE_OPTIONS: |
-        -DCMAKE_TOOLCHAIN_FILE=$GITHUB_WORKSPACE/ohos-sdk/linux/native/build/cmake/ohos.toolchain.cmake \
-        -DCMAKE_INSTALL_PREFIX=install \
-        -DCMAKE_BUILD_TYPE=Release \
-    steps:
-    - uses: actions/checkout@v6
-    - name: ndk-install
-      run: |
-        wget https://repo.huaweicloud.com/harmonyos/os/4.1.1-Release/ohos-sdk-windows_linux-public.tar.gz
-        tar -xf ohos-sdk-windows_linux-public.tar.gz
-        cd ohos-sdk/linux
-        unzip -q native-linux-x64-4.1.7.8-Release.zip
-        cd -
-    - name: build-armv8
-      run: |
-       mkdir build && cd build
-       ${{ env.OHOS_NDK_CMAKE }} ${{ env.COMMON_CMAKE_OPTIONS }} -DOHOS_ARCH="arm64-v8a" \
-       -DTARGET=ARMV8 -DNOFORTRAN=1 ..
-       ${{ env.OHOS_NDK_CMAKE }} --build . -j $(nproc)
-       

.github/workflows/loongarch64.yml

@@ -1,134 +0,0 @@
-name: loongarch64 qemu test
-
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  TEST:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-24.04
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - target: LOONGSONGENERIC
-            triple:  loongarch64-linux-gnu
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LOONGSONGENERIC
-          - target: LOONGSON3R5
-            triple: loongarch64-linux-gnu
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LOONGSON3R5
-          - target: LOONGSON2K1000
-            triple: loongarch64-linux-gnu
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LOONGSON2K1000
-          - target: LA64_GENERIC
-            triple:  loongarch64-linux-gnu
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LA64_GENERIC
-          - target: LA464
-            triple: loongarch64-linux-gnu
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LA464
-          - target: LA264
-            triple: loongarch64-linux-gnu
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LA264
-          - target: DYNAMIC_ARCH
-            triple: loongarch64-linux-gnu
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=GENERIC
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install APT deps
-        run: |
-          sudo apt-get update && \
-          sudo apt-get install autoconf automake autotools-dev ninja-build make ccache \
-                               gcc-14-loongarch64-linux-gnu g++-14-loongarch64-linux-gnu gfortran-14-loongarch64-linux-gnu
-
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.target }}
-
-      - name: Configure ccache
-        run: |
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-
-      - name: Install QEMU 10.2.1
-        run: |
-          qemu_deb="${RUNNER_TEMP}/qemu-user_10.2.1+ds-1ubuntu3_amd64.deb"
-          qemu_root="${RUNNER_TEMP}/qemu-user-10.2.1"
-          wget --output-document="${qemu_deb}" \
-            https://archive.ubuntu.com/ubuntu/pool/universe/q/qemu/qemu-user_10.2.1+ds-1ubuntu3_amd64.deb
-          echo "e6bdaac070232a44b8657cad84ac0853d84b7167b55af82370af040291f55bd8  ${qemu_deb}" \
-            | sha256sum --check -
-          dpkg-deb --extract "${qemu_deb}" "${qemu_root}"
-          sudo install -m 0755 "${qemu_root}/usr/bin/qemu-loongarch64" \
-            /usr/local/bin/qemu-loongarch64-static
-          qemu-loongarch64-static --version
-
-      - name: Build OpenBLAS
-        run: |
-          make CC='ccache ${{ matrix.triple }}-gcc-14 -static' FC='ccache ${{ matrix.triple }}-gfortran-14 -static' \
-          RANLIB='ccache ${{ matrix.triple }}-gcc-ranlib-14' ${{ matrix.opts }} HOSTCC='ccache gcc' -j$(nproc)
-
-      - name: Test
-        run: |
-          qemu-loongarch64-static ./utest/openblas_utest
-          qemu-loongarch64-static ./utest/openblas_utest_ext
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xscblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xdcblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xccblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xzcblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xscblat2 < ./ctest/sin2
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xdcblat2 < ./ctest/din2
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xccblat2 < ./ctest/cin2
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xzcblat2 < ./ctest/zin2
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xscblat3 < ./ctest/sin3
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xdcblat3 < ./ctest/din3
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xccblat3 < ./ctest/cin3
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./ctest/xzcblat3 < ./ctest/zin3
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/sblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/dblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/cblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/zblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/sblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/dblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/cblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/zblat1
-          rm -f ./test/?BLAT2.SUMM
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/sblat2 < ./test/sblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/dblat2 < ./test/dblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/cblat2 < ./test/cblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/zblat2 < ./test/zblat2.dat
-          rm -f ./test/?BLAT2.SUMM
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/sblat2 < ./test/sblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/dblat2 < ./test/dblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/cblat2 < ./test/cblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/zblat2 < ./test/zblat2.dat
-          rm -f ./test/?BLAT3.SUMM
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/sblat3 < ./test/sblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/dblat3 < ./test/dblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/cblat3 < ./test/cblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64-static ./test/zblat3 < ./test/zblat3.dat
-          rm -f ./test/?BLAT3.SUMM
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/sblat3 < ./test/sblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/dblat3 < ./test/dblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/cblat3 < ./test/cblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64-static ./test/zblat3 < ./test/zblat3.dat

.github/workflows/loongarch64_clang.yml

@@ -1,143 +0,0 @@
-name: loongarch64 clang qemu test
-
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-jobs:
-  TEST:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - target: LOONGSONGENERIC
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LOONGSONGENERIC
-          - target: LOONGSON3R5
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LOONGSON3R5
-          - target: LOONGSON2K1000
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LOONGSON2K1000
-          - target: LA64_GENERIC
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LA64_GENERIC
-          - target: LA464
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LA464
-          - target: LA264
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=LA264
-          - target: DYNAMIC_ARCH
-            opts: NO_SHARED=1 DYNAMIC_ARCH=1 TARGET=GENERIC
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install libffi6
-        run: |
-          wget https://download.nvidia.com/cumulus/apt.cumulusnetworks.com/pool/upstream/libf/libffi/libffi6_3.2.1-9_amd64.deb
-          sudo dpkg -i libffi6_3.2.1-9_amd64.deb
-
-      - name: Install APT deps
-        run: |
-          sudo apt-get update
-          sudo apt-get install autoconf automake autotools-dev ninja-build make ccache libglib2.0-dev
-
-      - name: Download and install loongarch64-toolchain
-        run: |
-          wget https://github.com/XiWeiGu/loongarch64_toolchain/releases/download/V0.1/clang+llvm_8.0.1-6_amd64-linux-gnu_debian-10.tar.gz
-          wget https://github.com/XiWeiGu/loongarch64_toolchain/releases/download/V0.1/loongson-gnu-toolchain-8.3-x86_64-loongarch64-linux-gnu-rc1.3.tar.xz
-          tar -xf clang+llvm_8.0.1-6_amd64-linux-gnu_debian-10.tar.gz -C /opt
-          tar -xf loongson-gnu-toolchain-8.3-x86_64-loongarch64-linux-gnu-rc1.3.tar.xz -C /opt
-
-      - name: Checkout qemu
-        uses: actions/checkout@v6
-        with:
-          repository: qemu/qemu
-          path: qemu
-          ref: master
-
-      - name: Install qemu
-        run: |
-          cd qemu
-          ./configure --prefix=$GITHUB_WORKSPACE/qemu-install --target-list=loongarch64-linux-user --disable-system --static
-          make -j$(nproc)
-          make install
-
-      - name: Set env
-        run: |
-          echo "PATH=$GITHUB_WORKSPACE:/opt/clang+llvm_8.0.1-6_amd64-linux-gnu_debian-10/bin:/opt/loongson-gnu-toolchain-8.3-x86_64-loongarch64-linux-gnu-rc1.3/bin:$PATH" >> $GITHUB_ENV
-
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.target }}
-
-      - name: Configure ccache
-        run: |
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-
-      - name: Build OpenBLAS
-        run: make CC='ccache clang --target=loongarch64-linux-gnu --sysroot=/opt/loongson-gnu-toolchain-8.3-x86_64-loongarch64-linux-gnu-rc1.3/loongarch64-linux-gnu/sysroot/ -static' FC='ccache loongarch64-linux-gnu-gfortran -static' HOSTCC='ccache clang' CROSS_SUFFIX=llvm-  NO_SHARED=1 ${{ matrix.opts }} -j$(nproc)
-
-      - name: Test
-        run: |
-          export PATH=$GITHUB_WORKSPACE/qemu-install/bin/:$PATH
-          qemu-loongarch64 ./utest/openblas_utest
-          qemu-loongarch64 ./utest/openblas_utest_ext
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xscblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xdcblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xccblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xzcblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xscblat2 < ./ctest/sin2
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xdcblat2 < ./ctest/din2
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xccblat2 < ./ctest/cin2
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xzcblat2 < ./ctest/zin2
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xscblat3 < ./ctest/sin3
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xdcblat3 < ./ctest/din3
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xccblat3 < ./ctest/cin3
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./ctest/xzcblat3 < ./ctest/zin3
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/sblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/dblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/cblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/zblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/sblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/dblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/cblat1
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/zblat1
-          rm -f ./test/?BLAT2.SUMM
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/sblat2 < ./test/sblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/dblat2 < ./test/dblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/cblat2 < ./test/cblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/zblat2 < ./test/zblat2.dat
-          rm -f ./test/?BLAT2.SUMM
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/sblat2 < ./test/sblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/dblat2 < ./test/dblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/cblat2 < ./test/cblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/zblat2 < ./test/zblat2.dat
-          rm -f ./test/?BLAT3.SUMM
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/sblat3 < ./test/sblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/dblat3 < ./test/dblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/cblat3 < ./test/cblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-loongarch64 ./test/zblat3 < ./test/zblat3.dat
-          rm -f ./test/?BLAT3.SUMM
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/sblat3 < ./test/sblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/dblat3 < ./test/dblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/cblat3 < ./test/cblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-loongarch64 ./test/zblat3 < ./test/zblat3.dat
-

.github/workflows/mips64.yml

@@ -1,131 +0,0 @@
-name: mips64 qemu test
-
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  TEST:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-latest
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - target: MIPS64_GENERIC
-            triple: mips64el-linux-gnuabi64
-            opts: NO_SHARED=1 TARGET=MIPS64_GENERIC
-          - target: SICORTEX
-            triple: mips64el-linux-gnuabi64
-            opts: NO_SHARED=1 TARGET=SICORTEX
-          - target: I6400
-            triple: mipsisa64r6el-linux-gnuabi64
-            opts: NO_SHARED=1 TARGET=I6400
-          - target: P6600
-            triple: mipsisa64r6el-linux-gnuabi64
-            opts: NO_SHARED=1 TARGET=P6600
-          - target: I6500
-            triple: mipsisa64r6el-linux-gnuabi64
-            opts: NO_SHARED=1 TARGET=I6500
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: install build deps
-        run: |
-          sudo apt-get update
-          sudo apt-get install autoconf automake autotools-dev ninja-build make ccache \
-          gcc-${{ matrix.triple }} gfortran-${{ matrix.triple }} libgomp1-mips64el-cross libglib2.0-dev
-
-      - name: checkout qemu
-        uses: actions/checkout@v6
-        with:
-          repository: qemu/qemu
-          path: qemu
-          ref: 3e0bcba1ca7d6607ca49a988d165f052a3a53323
-
-      - name: build qemu
-        run: |
-          cd qemu
-          ./configure --prefix=$GITHUB_WORKSPACE/qemu-install --target-list=mips64el-linux-user --disable-system
-          make -j$(nproc)
-          make install
-
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.target }}
-
-      - name: Configure ccache
-        run: |
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-
-      - name: build OpenBLAS
-        run: make CC='ccache ${{ matrix.triple }}-gcc -static' FC='ccache ${{ matrix.triple }}-gfortran -static' ${{ matrix.opts }} HOSTCC='ccache gcc' -j$(nproc)
-
-      - name: test
-        run: |
-          export PATH=$GITHUB_WORKSPACE/qemu-install/bin/:$PATH
-          qemu-mips64el ./utest/openblas_utest
-          qemu-mips64el ./utest/openblas_utest_ext
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xscblat1
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xdcblat1
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xccblat1
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xzcblat1
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xscblat2 < ./ctest/sin2
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xdcblat2 < ./ctest/din2
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xccblat2 < ./ctest/cin2
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xzcblat2 < ./ctest/zin2
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xscblat3 < ./ctest/sin3
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xdcblat3 < ./ctest/din3
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xccblat3 < ./ctest/cin3
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./ctest/xzcblat3 < ./ctest/zin3
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/sblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/dblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/cblat1
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/zblat1
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/sblat1
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/dblat1
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/cblat1
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/zblat1
-          rm -f ./test/?BLAT2.SUMM
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/sblat2 < ./test/sblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/dblat2 < ./test/dblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/cblat2 < ./test/cblat2.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/zblat2 < ./test/zblat2.dat
-          rm -f ./test/?BLAT2.SUMM
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/sblat2 < ./test/sblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/dblat2 < ./test/dblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/cblat2 < ./test/cblat2.dat
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/zblat2 < ./test/zblat2.dat
-          rm -f ./test/?BLAT3.SUMM
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/sblat3 < ./test/sblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/dblat3 < ./test/dblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/cblat3 < ./test/cblat3.dat
-          OPENBLAS_NUM_THREADS=1 OMP_NUM_THREADS=1 qemu-mips64el ./test/zblat3 < ./test/zblat3.dat
-          rm -f ./test/?BLAT3.SUMM
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/sblat3 < ./test/sblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/dblat3 < ./test/dblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/cblat3 < ./test/cblat3.dat
-          OPENBLAS_NUM_THREADS=2 qemu-mips64el ./test/zblat3 < ./test/zblat3.dat

.github/workflows/nightly-Homebrew-build.yml

@@ -17,17 +17,8 @@ on:
 # it only makes sense to test if this file has been changed
 
 name: Nightly-Homebrew-Build
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
 jobs:
   build-OpenBLAS-with-Homebrew:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
     runs-on: macos-latest
     env:
       DEVELOPER_DIR: /Applications/Xcode_11.4.1.app/Contents/Developer
@@ -37,8 +28,6 @@ jobs:
       HOMEBREW_NO_AUTO_UPDATE: "ON"
       HOMEBREW_NO_BOTTLE_SOURCE_FALLBACK: "ON"
       HOMEBREW_NO_INSTALL_CLEANUP: "ON"
-      HOMEBREW_NO_INSTALLED_DEPENDENTS_CHECK: "ON"
-      HOMEBREW_NO_INSTALL_FROM_API: "ON"      
 
     steps:
       - name: Random delay for cron job
@@ -48,7 +37,7 @@ jobs:
           sleep ${delay}
         if: github.event_name == 'schedule'
 
-      - uses: actions/checkout@v6
+      - uses: actions/checkout@v2
         # This isn't even needed, technically. Homebrew will get `develop` via git
 
       - name: Update Homebrew
@@ -69,7 +58,7 @@ jobs:
           mv *.bottle.tar.gz bottles
 
       - name: Upload bottle
-        uses: actions/upload-artifact@v7
+        uses: actions/upload-artifact@v1
         with:
           name: openblas--HEAD.catalina.bottle.tar.gz
           path: bottles

.github/workflows/riscv64_vector.yml

@@ -1,277 +0,0 @@
-name: riscv64 zvl256b qemu test
-
-on:
-  push:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  TEST:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: ubuntu-latest
-    env:
-      triple: riscv64-unknown-linux-gnu
-      riscv_gnu_toolchain: https://github.com/riscv-collab/riscv-gnu-toolchain
-      riscv_gnu_toolchain_version: 15.1.0
-      riscv_gnu_toolchain_nightly_download_path: /releases/download/2025.08.29/riscv64-glibc-ubuntu-22.04-llvm-nightly-2025.08.29-nightly.tar.xz
-    strategy:
-      fail-fast: false
-      matrix:
-        include:
-          - target: RISCV64_ZVL128B
-            opts: TARGET=RISCV64_ZVL128B BINARY=64 ARCH=riscv64
-            qemu_cpu: rv64,g=true,c=true,v=true,vext_spec=v1.0,vlen=128,elen=64
-          - target: RISCV64_ZVL256B
-            opts: TARGET=RISCV64_ZVL256B BINARY=64 ARCH=riscv64 BUILD_BFLOAT16=1 BUILD_HFLOAT16=1
-            qemu_cpu: rv64,g=true,c=true,v=true,vext_spec=v1.0,vlen=256,elen=64,zfh=true,zvfh=true,zvfbfwma=true
-          - target: DYNAMIC_ARCH=1
-            opts: TARGET=RISCV64_GENERIC BINARY=64 ARCH=riscv64 DYNAMIC_ARCH=1
-            qemu_cpu: rv64,g=true,c=true,v=true,vext_spec=v1.0,vlen=256,elen=64
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: install build deps
-        run: |
-          sudo apt-get update
-          sudo apt-get install autoconf automake autotools-dev ninja-build make \
-          libgomp1-riscv64-cross ccache qemu-kvm qemu-user libc6-riscv64-cross
-          wget ${riscv_gnu_toolchain}/${riscv_gnu_toolchain_nightly_download_path}
-          tar -xvf $(basename ${riscv_gnu_toolchain_nightly_download_path}) -C /opt
-          wget https://gist.github.com/martin-frbg/bb630e0de34978e578eeb496b1538d4e/raw/7fd8d971f327f7a517b8f5f7989479ff2b36f71f/qemu-riscv64-10.1-ubuntu24 -P /opt/riscv/bin -o riscv64-qemu
-          mv /opt/riscv/bin/qemu-riscv64-10.1-ubuntu24 /opt/riscv/bin/qemu-riscv64
-          chmod +x /opt/riscv/bin/qemu-riscv64
-          
-      - name: Compilation cache
-        uses: actions/cache@v5
-        with:
-          path: ~/.ccache
-          key: ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}-${{ github.sha }}
-          restore-keys: |
-            ccache-${{ runner.os }}-${{ matrix.target }}-${{ github.ref }}
-            ccache-${{ runner.os }}-${{ matrix.target }}
-
-      - name: Configure ccache
-        run: |
-          test -d ~/.ccache || mkdir -p ~/.ccache
-          echo "max_size = 300M" > ~/.ccache/ccache.conf
-          echo "compression = true" >> ~/.ccache/ccache.conf
-          ccache -s
-
-      - name: build OpenBLAS libs
-        run: |
-            export PATH="/opt/riscv/bin:$PATH"
-            make TARGET=${{ matrix.target }} CFLAGS="-DTARGET=${{ matrix.target }}" \
-            CC='ccache clang --rtlib=compiler-rt -target ${triple} --sysroot /opt/riscv/sysroot --gcc-toolchain=/opt/riscv/lib/gcc/riscv64-unknown-linux-gnu/${riscv_gnu_toolchain_version}/' \
-            AR='ccache ${triple}-ar' AS='ccache ${triple}-gcc' LD='ccache ${triple}-gcc' \
-            RANLIB='ccache ${triple}-ranlib' \
-            FC='ccache ${triple}-gfortran' ${{ matrix.opts }} \
-            HOSTCC=gcc HOSTFC=gfortran -j$(nproc)
-
-      - name: build OpenBLAS tests
-        run: |
-            export PATH="/opt/riscv/bin:$PATH"
-            make TARGET=${{ matrix.target }} CFLAGS="-DTARGET=${{ matrix.target }}" \
-            CC='ccache clang --rtlib=compiler-rt -target ${triple} --sysroot /opt/riscv/sysroot --gcc-toolchain=/opt/riscv/lib/gcc/riscv64-unknown-linux-gnu/${riscv_gnu_toolchain_version}/' \
-            AR='ccache ${triple}-ar' AS='ccache ${triple}-gcc' LD='ccache ${triple}-gcc' \
-            RANLIB='ccache ${triple}-ranlib' \
-            FC='ccache ${triple}-gfortran' ${{ matrix.opts }} \
-            HOSTCC=gcc HOSTFC=gfortran -j$(nproc) tests
-
-      - name: build lapack-netlib tests
-        working-directory: ./lapack-netlib/TESTING
-        run: |
-            export PATH="/opt/riscv/bin:$PATH"
-            make TARGET=${{ matrix.target }} CFLAGS="-DTARGET=${{ matrix.target }}" \
-            CC='${triple}-gcc' \
-            AR='ccache ${triple}-ar' AS='ccache ${triple}-gcc' LD='ccache ${triple}-gcc' \
-            RANLIB='ccache ${triple}-ranlib' \
-            FC='ccache ${triple}-gfortran' ${{ matrix.opts }} \
-            HOSTCC=gcc HOSTFC=gfortran -j$(nproc) \
-            LIN/xlintsts LIN/xlintstc LIN/xlintstd LIN/xlintstz LIN/xlintstrfs \
-            LIN/xlintstrfc LIN/xlintstrfd LIN/xlintstrfz LIN/xlintstds \
-            LIN/xlintstzc EIG/xeigtsts EIG/xeigtstc EIG/xeigtstd EIG/xeigtstz \
-
-      - name: OpenBLAS tests
-        shell: bash
-        run: |
-          export PATH="/opt/riscv/bin:$PATH"
-          export LD_LIBRARY_PATH=/opt/riscv/sysroot/lib
-          sudo ln -s /opt/riscv/sysroot/lib/ld-linux-riscv64-lp64d.so.1 /lib
-          export QEMU_CPU=${{ matrix.qemu_cpu }}
-          rm -rf ./test_out
-          mkdir -p ./test_out
-          run_test() { local DIR=$1; local CMD=$2; local DATA=$3; local OUTPUT="./test_out/$DIR.$CMD"; \
-            echo "`pwd`/$DIR/$CMD $DIR/$DATA" >> $OUTPUT; \
-            if [[ -z $DATA ]]; then qemu-riscv64 ./$DIR/$CMD |& tee $OUTPUT ; \ 
-            else qemu-riscv64 ./$DIR/$CMD < ./$DIR/$DATA |& tee $OUTPUT ; fi ; \
-            RV=$? ; if [[ $RV != 0 ]]; then echo "*** FAIL: nonzero exit code $RV" >> $OUTPUT ; fi \
-          }
-          run_test test cblat1 &
-          run_test test cblat2 cblat2.dat &
-          run_test test cblat3 cblat3.dat &
-          run_test test dblat1 &
-          run_test test dblat2 dblat2.dat &
-          run_test test dblat3 dblat3.dat &
-          run_test test sblat1 &
-          run_test test sblat2 sblat2.dat &
-          run_test test sblat3 sblat3.dat &
-          run_test test zblat1 &
-          run_test test zblat2 zblat2.dat &
-          run_test test zblat3 zblat3.dat &
-          run_test ctest xccblat1 &
-          run_test ctest xccblat2 cin2 &
-          run_test ctest xccblat3 cin3 &
-          run_test ctest xdcblat1 &
-          run_test ctest xdcblat2 din2 &
-          run_test ctest xdcblat3 din3 &
-          run_test ctest xscblat1 &
-          run_test ctest xscblat2 sin2 &
-          run_test ctest xscblat3 sin3 &
-          run_test ctest xzcblat1 &
-          run_test ctest xzcblat2 zin2 &
-          run_test ctest xzcblat3 zin3 &
-          wait
-          while IFS= read -r -d $'\0' LOG; do cat $LOG ; FAILURES=1 ; done < <(grep -lZ FAIL ./test_out/*)
-          if [[ ! -z $FAILURES ]]; then echo "==========" ; echo "== FAIL ==" ; echo "==========" ; echo ; exit 1 ; fi
-          if [ "${{matrix.target}}" == "RISCV64_ZVL256B" ]; then
-          qemu-riscv64 test/test_sbgemm &
-          qemu-riscv64 test/test_sbgemv &
-          qemu-riscv64 test/test_shgemm &
-          qemu-riscv64 test/test_shgemv &
-          qemu-riscv64 test/test_bgemm
-          fi
-
-
-      - name: netlib tests
-        shell: bash
-        run: |
-          : # these take a very long time
-          echo "Skipping netlib tests in CI"
-          exit 0
-          : # comment out exit above to enable the tests
-          : # probably we want to identify a subset to run in CI
-          export PATH="/opt/riscv/bin:$PATH"
-          export QEMU_CPU=${{ matrix.qemu_cpu }}
-          rm -rf ./test_out
-          mkdir -p ./test_out
-          run_test() { local OUTPUT="./test_out/$1"; local DATA="./lapack-netlib/TESTING/$2"; local CMD="./lapack-netlib/TESTING/$3"; \
-            echo "$4" >> $OUTPUT; \
-            echo "$CMD" >> $OUTPUT; \
-            qemu-riscv64 $CMD < $DATA |& tee $OUTPUT; \
-            RV=$? ; if [[ $RV != 0 ]]; then echo "*** FAIL: nonzero exit code $RV" >> $OUTPUT ; fi; \
-            if grep -q fail $OUTPUT ; then echo "*** FAIL: log contains 'fail'" >> $OUTPUT ; fi ; \
-            if grep -q rror $OUTPUT | grep -v -q "passed" | grep -v "largest error" ; then echo "*** FAIL: log contains 'error'" >> $OUTPUT ; fi \
-          }
-          run_test stest.out stest.in LIN/xlintsts "Testing REAL LAPACK linear equation routines"  &
-          run_test ctest.out ctest.in LIN/xlintstc "Testing COMPLEX LAPACK linear equation routines"  &
-          run_test dtest.out dtest.in LIN/xlintstd "Testing DOUBLE PRECISION LAPACK linear equation routines"  &
-          run_test ztest.out ztest.in LIN/xlintstz "Testing COMPLEX16 LAPACK linear equation routines"  &
-          run_test dstest.out dstest.in LIN/xlintstds "Testing SINGLE-DOUBLE PRECISION LAPACK prototype linear equation routines"  &
-          run_test zctest.out zctest.in LIN/xlintstzc "Testing COMPLEX-COMPLEX16 LAPACK prototype linear equation routines"  &
-          run_test stest_rfp.out stest_rfp.in LIN/xlintstrfs "Testing REAL LAPACK RFP prototype linear equation routines"  &
-          run_test dtest_rfp.out dtest_rfp.in LIN/xlintstrfd "Testing DOUBLE PRECISION LAPACK RFP prototype linear equation routines"  &
-          run_test ctest_rfp.out ctest_rfp.in LIN/xlintstrfc "Testing COMPLEX LAPACK RFP prototype linear equation routines"  &
-          run_test ztest_rfp.out ztest_rfp.in LIN/xlintstrfz "Testing COMPLEX16 LAPACK RFP prototype linear equation routines"  &
-          run_test snep.out nep.in EIG/xeigtsts "NEP - Testing Nonsymmetric Eigenvalue Problem routines"  &
-          run_test ssep.out sep.in EIG/xeigtsts "SEP - Testing Symmetric Eigenvalue Problem routines"  &
-          run_test sse2.out se2.in EIG/xeigtsts "SEP - Testing Symmetric Eigenvalue Problem routines"  &
-          run_test ssvd.out svd.in EIG/xeigtsts "SVD - Testing Singular Value Decomposition routines"  &
-          run_test sec.out sec.in EIG/xeigtsts "SEC - Testing REAL Eigen Condition Routines"  &
-          run_test sed.out sed.in EIG/xeigtsts "SEV - Testing REAL Nonsymmetric Eigenvalue Driver"  &
-          run_test sgg.out sgg.in EIG/xeigtsts "SGG - Testing REAL Nonsymmetric Generalized Eigenvalue Problem routines"  &
-          run_test sgd.out sgd.in EIG/xeigtsts "SGD - Testing REAL Nonsymmetric Generalized Eigenvalue Problem driver routines"  &
-          run_test ssb.out ssb.in EIG/xeigtsts "SSB - Testing REAL Symmetric Eigenvalue Problem routines"  &
-          run_test ssg.out ssg.in EIG/xeigtsts "SSG - Testing REAL Symmetric Generalized Eigenvalue Problem routines"  &
-          run_test sbal.out sbal.in EIG/xeigtsts "SGEBAL - Testing the balancing of a REAL general matrix"  &
-          run_test sbak.out sbak.in EIG/xeigtsts "SGEBAK - Testing the back transformation of a REAL balanced matrix"  &
-          run_test sgbal.out sgbal.in EIG/xeigtsts "SGGBAL - Testing the balancing of a pair of REAL general matrices"  &
-          run_test sgbak.out sgbak.in EIG/xeigtsts "SGGBAK - Testing the back transformation of a pair of REAL balanced matrices"  &
-          run_test sbb.out sbb.in EIG/xeigtsts "SBB - Testing banded Singular Value Decomposition routines"  &
-          run_test sglm.out glm.in EIG/xeigtsts "GLM - Testing Generalized Linear Regression Model routines"  &
-          run_test sgqr.out gqr.in EIG/xeigtsts "GQR - Testing Generalized QR and RQ factorization routines"  &
-          run_test sgsv.out gsv.in EIG/xeigtsts "GSV - Testing Generalized Singular Value Decomposition routines"  &
-          run_test scsd.out csd.in EIG/xeigtsts "CSD - Testing CS Decomposition routines"  &
-          run_test slse.out lse.in EIG/xeigtsts "LSE - Testing Constrained Linear Least Squares routines"  &
-          run_test cnep.out nep.in EIG/xeigtstc "NEP - Testing Nonsymmetric Eigenvalue Problem routines"  &
-          run_test csep.out sep.in EIG/xeigtstc "SEP - Testing Symmetric Eigenvalue Problem routines"  &
-          run_test cse2.out se2.in EIG/xeigtstc "SEP - Testing Symmetric Eigenvalue Problem routines"  &
-          run_test csvd.out svd.in EIG/xeigtstc "SVD - Testing Singular Value Decomposition routines"  &
-          run_test cec.out cec.in EIG/xeigtstc "CEC - Testing COMPLEX Eigen Condition Routines"  &
-          run_test ced.out ced.in EIG/xeigtstc "CES - Testing COMPLEX Nonsymmetric Schur Form Driver"  &
-          run_test cgg.out cgg.in EIG/xeigtstc "CGG - Testing COMPLEX Nonsymmetric Generalized Eigenvalue Problem routines"  &
-          run_test cgd.out cgd.in EIG/xeigtstc "CGD - Testing COMPLEX Nonsymmetric Generalized Eigenvalue Problem driver routines"  &
-          run_test csb.out csb.in EIG/xeigtstc "CHB - Testing Hermitian Eigenvalue Problem routines"  &
-          run_test csg.out csg.in EIG/xeigtstc "CSG - Testing Symmetric Generalized Eigenvalue Problem routines"  &
-          run_test cbal.out cbal.in EIG/xeigtstc "CGEBAL - Testing the balancing of a COMPLEX general matrix"  &
-          run_test cbak.out cbak.in EIG/xeigtstc "CGEBAK - Testing the back transformation of a COMPLEX balanced matrix"  &
-          run_test cgbal.out cgbal.in EIG/xeigtstc "CGGBAL - Testing the balancing of a pair of COMPLEX general matrices"  &
-          run_test cgbak.out cgbak.in EIG/xeigtstc "CGGBAK - Testing the back transformation of a pair of COMPLEX balanced matrices"  &
-          run_test cbb.out cbb.in EIG/xeigtstc "CBB - Testing banded Singular Value Decomposition routines"  &
-          run_test cglm.out glm.in EIG/xeigtstc "GLM - Testing Generalized Linear Regression Model routines"  &
-          run_test cgqr.out gqr.in EIG/xeigtstc "GQR - Testing Generalized QR and RQ factorization routines"  &
-          run_test cgsv.out gsv.in EIG/xeigtstc "GSV - Testing Generalized Singular Value Decomposition routines"  &
-          run_test ccsd.out csd.in EIG/xeigtstc "CSD - Testing CS Decomposition routines"  &
-          run_test clse.out lse.in EIG/xeigtstc "LSE - Testing Constrained Linear Least Squares routines"  &
-          run_test dnep.out nep.in EIG/xeigtstd "NEP - Testing Nonsymmetric Eigenvalue Problem routines"  &
-          run_test dsep.out sep.in EIG/xeigtstd "SEP - Testing Symmetric Eigenvalue Problem routines"  &
-          run_test dse2.out se2.in EIG/xeigtstd "SEP - Testing Symmetric Eigenvalue Problem routines"  &
-          run_test dsvd.out svd.in EIG/xeigtstd "SVD - Testing Singular Value Decomposition routines"  &
-          run_test dec.out dec.in EIG/xeigtstd "DEC - Testing DOUBLE PRECISION Eigen Condition Routines"  &
-          run_test ded.out ded.in EIG/xeigtstd "DEV - Testing DOUBLE PRECISION Nonsymmetric Eigenvalue Driver"  &
-          run_test dgg.out dgg.in EIG/xeigtstd "DGG - Testing DOUBLE PRECISION Nonsymmetric Generalized Eigenvalue Problem routines"  &
-          run_test dgd.out dgd.in EIG/xeigtstd "DGD - Testing DOUBLE PRECISION Nonsymmetric Generalized Eigenvalue Problem driver routines"  &
-          run_test dsb.out dsb.in EIG/xeigtstd "DSB - Testing DOUBLE PRECISION Symmetric Eigenvalue Problem routines"  &
-          run_test dsg.out dsg.in EIG/xeigtstd "DSG - Testing DOUBLE PRECISION Symmetric Generalized Eigenvalue Problem routines"  &
-          run_test dbal.out dbal.in EIG/xeigtstd "DGEBAL - Testing the balancing of a DOUBLE PRECISION general matrix"  &
-          run_test dbak.out dbak.in EIG/xeigtstd "DGEBAK - Testing the back transformation of a DOUBLE PRECISION balanced matrix"  &
-          run_test dgbal.out dgbal.in EIG/xeigtstd "DGGBAL - Testing the balancing of a pair of DOUBLE PRECISION general matrices"  &
-          run_test dgbak.out dgbak.in EIG/xeigtstd "DGGBAK - Testing the back transformation of a pair of DOUBLE PRECISION balanced matrices"  &
-          run_test dbb.out dbb.in EIG/xeigtstd "DBB - Testing banded Singular Value Decomposition routines"  &
-          run_test dglm.out glm.in EIG/xeigtstd "GLM - Testing Generalized Linear Regression Model routines"  &
-          run_test dgqr.out gqr.in EIG/xeigtstd "GQR - Testing Generalized QR and RQ factorization routines"  &
-          run_test dgsv.out gsv.in EIG/xeigtstd "GSV - Testing Generalized Singular Value Decomposition routines"  &
-          run_test dcsd.out csd.in EIG/xeigtstd "CSD - Testing CS Decomposition routines"  &
-          run_test dlse.out lse.in EIG/xeigtstd "LSE - Testing Constrained Linear Least Squares routines"  &
-          run_test znep.out nep.in EIG/xeigtstz "NEP - Testing Nonsymmetric Eigenvalue Problem routines"  &
-          run_test zsep.out sep.in EIG/xeigtstz "SEP - Testing Symmetric Eigenvalue Problem routines"  &
-          run_test zse2.out se2.in EIG/xeigtstz "SEP - Testing Symmetric Eigenvalue Problem routines"  &
-          run_test zsvd.out svd.in EIG/xeigtstz "SVD - Testing Singular Value Decomposition routines"  &
-          run_test zec.out zec.in EIG/xeigtstz "ZEC - Testing COMPLEX16 Eigen Condition Routines"  &
-          run_test zed.out zed.in EIG/xeigtstz "ZES - Testing COMPLEX16 Nonsymmetric Schur Form Driver"  &
-          run_test zgg.out zgg.in EIG/xeigtstz "ZGG - Testing COMPLEX16 Nonsymmetric Generalized Eigenvalue Problem routines"  &
-          run_test zgd.out zgd.in EIG/xeigtstz "ZGD - Testing COMPLEX16 Nonsymmetric Generalized Eigenvalue Problem driver routines"  &
-          run_test zsb.out zsb.in EIG/xeigtstz "ZHB - Testing Hermitian Eigenvalue Problem routines"  &
-          run_test zsg.out zsg.in EIG/xeigtstz "ZSG - Testing Symmetric Generalized Eigenvalue Problem routines"  &
-          run_test zbal.out zbal.in EIG/xeigtstz "ZGEBAL - Testing the balancing of a COMPLEX16 general matrix"  &
-          run_test zbak.out zbak.in EIG/xeigtstz "ZGEBAK - Testing the back transformation of a COMPLEX16 balanced matrix"  &
-          run_test zgbal.out zgbal.in EIG/xeigtstz "ZGGBAL - Testing the balancing of a pair of COMPLEX general matrices"  &
-          run_test zgbak.out zgbak.in EIG/xeigtstz "ZGGBAK - Testing the back transformation of a pair of COMPLEX16 balanced matrices"  &
-          run_test zbb.out zbb.in EIG/xeigtstz "ZBB - Testing banded Singular Value Decomposition routines"  &
-          run_test zglm.out glm.in EIG/xeigtstz "GLM - Testing Generalized Linear Regression Model routines"  &
-          run_test zgqr.out gqr.in EIG/xeigtstz "GQR - Testing Generalized QR and RQ factorization routines"  &
-          run_test zgsv.out gsv.in EIG/xeigtstz "GSV - Testing Generalized Singular Value Decomposition routines"  &
-          run_test zcsd.out csd.in EIG/xeigtstz "CSD - Testing CS Decomposition routines"  &
-          run_test zlse.out lse.in EIG/xeigtstz "LSE - Testing Constrained Linear Least Squares routines"  &
-          wait
-          while IFS= read -r -d $'\0' LOG; do cat $LOG ; FAILURES=1 ;  done < <(grep -lZ FAIL ./test_out/*)
-          python ./lapack-netlib/lapack_testing.py -d ./test_out -e > netlib_summary
-          TOTALS="$(grep 'ALL PRECISIONS' netlib_summary)"
-          NUMERICAL_ERRORS=-1
-          OTHER_ERRORS=-1
-          . <(awk '/ALL PRECISIONS/{printf "NUMERICAL_ERRORS=%s\nOTHER_ERRORS=%s\n", $5, $7}' netlib_summary
-          if (( NUMERICAL_ERRORS != 0 )) || (( OTHER_ERRORS != 0 )) ; then cat netlib_summary ; FAILURES=1 ; fi
-          if [[ ! -z $FAILURES ]]; then echo "==========" ; echo "== FAIL ==" ; echo "==========" ; echo ; exit 1 ; fi

.github/workflows/windows_arm64.yml

@@ -1,90 +0,0 @@
-name: Windows ARM64 CI
-
-on:
-  push:
-    branches:
-      - develop
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-  pull_request:
-    branches:
-      - develop
-    paths-ignore:
-      - 'docs/**'
-      - '**/*.md'
-
-concurrency:
-  group: ${{ github.workflow }}-${{ github.head_ref || github.run_id }}
-  cancel-in-progress: true
-
-permissions:
-  contents: read # to fetch code (actions/checkout)
-
-jobs:
-  build:
-    if: "github.repository == 'OpenMathLib/OpenBLAS'"
-    runs-on: windows-11-arm
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v6
-
-      - name: Install LLVM for Win-ARM64
-        shell: pwsh
-        run: |
-          Invoke-WebRequest https://github.com/llvm/llvm-project/releases/download/llvmorg-20.1.8/LLVM-20.1.8-woa64.exe -UseBasicParsing -OutFile LLVM-woa64.exe
-          Start-Process -FilePath ".\LLVM-woa64.exe" -ArgumentList "/S" -Wait
-          echo "C:\Program Files\LLVM\bin" | Out-File -FilePath $env:GITHUB_PATH -Encoding utf8 -Append
-          #dir "C:\Program Files\LLVM\include\flang"
-          #rmdir /Q /S "C:/Program Files/Microsoft Visual Studio/2022/Enterprise/VC/Tools/Llvm/ARM64"
-          
-      - name: Install CMake and Ninja for Win-ARM64
-        shell: pwsh
-        run: |
-          Invoke-WebRequest https://github.com/Kitware/CMake/releases/download/v3.29.4/cmake-3.29.4-windows-arm64.msi -OutFile cmake-arm64.msi
-          Start-Process msiexec.exe -ArgumentList "/i cmake-arm64.msi /quiet /norestart" -Wait
-          echo "C:\Program Files\CMake\bin" >> $env:GITHUB_PATH
-          
-          Invoke-WebRequest https://github.com/ninja-build/ninja/releases/download/v1.13.1/ninja-winarm64.zip -OutFile ninja-winarm64.zip
-          Expand-Archive ninja-winarm64.zip -DestinationPath ninja
-          Copy-Item ninja\ninja.exe -Destination "C:\Windows\System32"
-
-      - name: Configure OpenBLAS
-        shell: cmd
-        run: |
-          CALL "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvarsarm64.bat"
-          set PATH=C:\Program Files\LLVM\bin;%PATH%
-          
-          mkdir build
-          cd build
-          cmake .. -G Ninja ^
-            -DCMAKE_BUILD_TYPE=Release ^
-            -DTARGET=ARMV8 ^
-            -DBINARY=64 ^
-            -DCMAKE_C_COMPILER=clang-cl ^
-            -DCMAKE_Fortran_COMPILER=flang-new ^
-            -DBUILD_SHARED_LIBS=ON ^
-            -DCMAKE_SYSTEM_PROCESSOR=arm64 ^
-            -DCMAKE_SYSTEM_NAME=Windows ^
-            -DCMAKE_INSTALL_PREFIX=C:/opt
-
-      - name: Build OpenBLAS
-        shell: cmd
-        run: |
-          cd build
-          ninja -j16
-
-      - name: Install OpenBLAS
-        shell: cmd
-        run: |
-          cd build
-          cmake --install .
-
-      - name: Run ctests 
-        shell: pwsh
-        run: |
-          $env:PATH = "C:\opt\bin;$env:PATH"
-          cd build
-          ctest
-
-

.gitignore

@@ -4,7 +4,6 @@
 *.dylib
 *.def
 *.o
-*.exe
 *.out
 *.tmp
 lapack-3.1.1
@@ -14,8 +13,7 @@ lapack-3.4.1.tgz
 lapack-3.4.2
 lapack-3.4.2.tgz
 lapack-netlib/make.inc
-lapack-netlib/SRC/la_constants.mod
-lapack-netlib/SRC/la_xisnan.mod
+lapack-netlib/lapacke/include/lapacke_mangling.h
 lapack-netlib/TESTING/testing_results.txt
 lapack-netlib/INSTALL/test*
 lapack-netlib/TESTING/xeigtstc
@@ -48,67 +46,44 @@ config_last.h
 getarch
 getarch_2nd
 utest/openblas_utest
-utest/openblas_utest_ext
 ctest/xccblat1
 ctest/xccblat2
 ctest/xccblat3
-ctest/xccblat3_3m
 ctest/xdcblat1
 ctest/xdcblat2
 ctest/xdcblat3
-ctest/xdcblat3_3m
 ctest/xscblat1
 ctest/xscblat2
 ctest/xscblat3
-ctest/xscblat3_3m
 ctest/xzcblat1
 ctest/xzcblat2
 ctest/xzcblat3
-ctest/xzcblat3_3m
 exports/linktest.c
 exports/linux.def
 kernel/setparam_*.c
 kernel/kernel_*.h
 test/CBLAT2.SUMM
 test/CBLAT3.SUMM
-test/CBLAT3_3M.SUMM
 test/DBLAT2.SUMM
 test/DBLAT3.SUMM
-test/DBLAT3_3M.SUMM
 test/SBLAT2.SUMM
 test/SBLAT3.SUMM
-test/SBLAT3_3M.SUMM
 test/ZBLAT2.SUMM
 test/ZBLAT3.SUMM
-test/ZBLAT3_3M.SUMM
-test/SHBLAT2.SUMM
 test/SHBLAT3.SUMM
-test/SBBLAT2.SUMM
-test/SBBLAT3.SUMM
-test/BBLAT2.SUMM
-test/BBLAT3.SUMM
 test/cblat1
 test/cblat2
 test/cblat3
-test/cblat3_3m
 test/dblat1
 test/dblat2
 test/dblat3
-test/dblat3_3m
 test/sblat1
 test/sblat2
 test/sblat3
-test/sblat3_3m
 test/test_shgemm
-test/test_shgemv
-test/test_sbgemm
-test/test_sbgemv
-test/test_bgemm
-test/test_bgemv
 test/zblat1
 test/zblat2
 test/zblat3
-test/zblat3_3m
 build
 build.*
 *.swp
@@ -118,4 +93,3 @@ benchmark/smallscaling
 CMakeCache.txt
 CMakeFiles/*
 .vscode
-**/__pycache__

.travis.yml

@@ -25,12 +25,11 @@ matrix:
 #        - BTYPE="BINARY=64"
 #
 #    - <<: *test-ubuntu
-      os: linux
-      arch: ppc64le
+      os: linux-ppc64le
       before_script: &common-before
         - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=POWER8 NUM_THREADS=32"
       script:
-        - travis_wait 50 make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
+        - make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE
         - make -C test $COMMON_FLAGS $BTYPE
         - make -C ctest $COMMON_FLAGS $BTYPE
         - make -C utest $COMMON_FLAGS $BTYPE
@@ -44,7 +43,6 @@ matrix:
       arch: s390x
       before_script:
         - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=Z13 NUM_THREADS=32"
-        - sudo apt-get install --only-upgrade binutils
       env:
         # for matrix annotation only
         - TARGET_BOX=IBMZ_LINUX
@@ -57,7 +55,6 @@ matrix:
       compiler: clang
       before_script:
         - COMMON_FLAGS="DYNAMIC_ARCH=1 TARGET=Z13 NUM_THREADS=32"
-        - sudo apt-get install --only-upgrade binutils
       env:
         # for matrix annotation only
         - TARGET_BOX=IBMZ_LINUX
@@ -104,7 +101,7 @@ matrix:
         - sudo apt-get update
         - sudo apt-get install gcc-9 gfortran-9 -y
       script:
-        - travis_wait 50 make QUIET_MAKE=1  BINARY=64 USE_OPENMP=1 CC=gcc-9 FC=gfortran-9
+        - make QUIET_MAKE=1  BINARY=64 USE_OPENMP=1 CC=gcc-9 FC=gfortran-9
         - make -C test $COMMON_FLAGS $BTYPE
         - make -C ctest $COMMON_FLAGS $BTYPE
         - make -C utest $COMMON_FLAGS $BTYPE 
@@ -121,7 +118,7 @@ matrix:
         - sudo apt-get update
         - sudo apt-get install gcc-9 gfortran-9 -y
       script:
-        - travis_wait 50 make QUIET_MAKE=1  BUILD_BFLOAT16=1 BINARY=64 USE_OPENMP=1 CC=gcc-9 FC=gfortran-9
+        - make QUIET_MAKE=1  BUILD_BFLOAT16=1 BINARY=64 USE_OPENMP=1 CC=gcc-9 FC=gfortran-9
         - make -C test $COMMON_FLAGS $BTYPE
         - make -C ctest $COMMON_FLAGS $BTYPE
         - make -C utest $COMMON_FLAGS $BTYPE 
@@ -272,9 +269,9 @@ matrix:
 #        - CFLAGS="-O2 -mno-thumb -Wno-macro-redefined -isysroot /Applications/Xcode-11.5.GM.Seed.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS13.5.sdk -arch armv7 -miphoneos-version-min=5.1"
 #        - BTYPE="TARGET=ARMV7 HOSTCC=clang NOFORTRAN=1"
 
-    - &test-neoversen1
+    - &test-graviton2
       os: linux
-      arch: arm64
+      arch: arm64-graviton2
       dist: focal
       group: edge
       virt: lxd
@@ -285,25 +282,6 @@ matrix:
             - gfortran
       script:
         - travis_wait 45 make && make lapack-test
-      env:
-        - TARGET_BOX=NEOVERSE_N1 
-  
-    - &test-neon1-gcc8
-      os: linux
-      arch: arm64
-      dist: focal
-      group: edge
-      virt: lxd
-      compiler: gcc
-      addons:
-        apt:
-          packages:
-            - gcc-8
-            - gfortran-8
-      script:
-        - travis_wait 45 make QUIET_MAKE=1 CC=gcc-8 FC=gfortran-8 DYNAMIC_ARCH=1 
-      env:
-        - TARGET_BOX=NEOVERSE_N1-GCC8
         
 # whitelist
 branches:

BACKERS.md

@@ -1,9 +1,5 @@
 Thank you for the support.
 
-### [2019.12/2021.9] [Chan-Zuckerberg Foundation EOSS Initiative](https://chanzuckerberg.com/eoss/)
-
-Between December 2019 and September 2021, development and maintaining of OpenBLAS was funded in part by the Chan-Zuckerberg Foundation in the context of  two grants awarded to the NumPy Foundation and managed by NumFocus (Cycles 1 and 3 of the Essential Open Source Software for Science (EOSS) Initiative of the Chan-Zuckerberg Foundation)  
-
 ### [2013.8] [Testbed for OpenBLAS project](https://www.bountysource.com/fundraisers/443-testbed-for-openblas-project)
 
 https://www.bountysource.com/fundraisers/443-testbed-for-openblas-project/pledges

CMakeLists.txt

@@ -2,14 +2,13 @@
 ## Author: Hank Anderson <hank@statease.com>
 ##
 
-cmake_minimum_required(VERSION 3.16.0)
+cmake_minimum_required(VERSION 2.8.5)
 
-set (CMAKE_ASM_SOURCE_FILE_EXTENSIONS "S")
 project(OpenBLAS C ASM)
 
 set(OpenBLAS_MAJOR_VERSION 0)
 set(OpenBLAS_MINOR_VERSION 3)
-set(OpenBLAS_PATCH_VERSION 34.dev)
+set(OpenBLAS_PATCH_VERSION 20)
 
 set(OpenBLAS_VERSION "${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.${OpenBLAS_PATCH_VERSION}")
 
@@ -18,24 +17,18 @@ include(GNUInstallDirs)
 
 include(CMakePackageConfigHelpers)
 
+if(MSVC AND NOT DEFINED NOFORTRAN)
+  set(NOFORTRAN ON)
+endif()
+
 #######
-option(BUILD_WITHOUT_LAPACK "Do not build LAPACK and LAPACKE (Only BLAS or CBLAS)" OFF)
-
-option(BUILD_WITHOUT_LAPACKE "Do not build the C interface to LAPACK)" OFF)
-
-option(BUILD_LAPACK_DEPRECATED "When building LAPACK, include also some older, deprecated routines" ON)
-
-set(LAPACK_STRLEN "" CACHE STRING "When building LAPACK, use this type (e.g. \"int\") for character lengths (defaults to size_t)")
-
-option(BUILD_TESTING "Build LAPACK testsuite when building LAPACK" ON)
-
-option(BUILD_BENCHMARKS "Build the collection of BLAS/LAPACK benchmarks" OFF)
-
-option(C_LAPACK "Build LAPACK from C sources instead of the original Fortran" OFF)
+if(MSVC)
+  option(BUILD_WITHOUT_LAPACK "Do not build LAPACK and LAPACKE (Only BLAS or CBLAS)" ON)
+endif()
 
 option(BUILD_WITHOUT_CBLAS "Do not build the C interface (CBLAS) to the BLAS functions" OFF)
 
-option(DYNAMIC_ARCH "Include support for multiple CPU targets, with automatic selection at runtime (x86/x86_64, aarch64, ppc or RISCV64-RVV1.0 only)" OFF)
+option(DYNAMIC_ARCH "Include support for multiple CPU targets, with automatic selection at runtime (x86/x86_64, aarch64 or ppc only)" OFF)
 
 option(DYNAMIC_OLDER "Include specific support for older x86 cpu models (Penryn,Dunnington,Atom,Nano,Opteron) with DYNAMIC_ARCH" OFF)
 
@@ -43,27 +36,16 @@ option(BUILD_RELAPACK "Build with ReLAPACK (recursive implementation of several
 
 option(USE_LOCKING "Use locks even in single-threaded builds to make them callable from multiple threads" OFF)
 
-option(USE_PERL "Use the older PERL scripts for build preparation instead of universal shell scripts" OFF)
-
-option(NO_WARMUP "Do not run a benchmark on each startup just to find the best location for the memory buffer" ON)
-
-option(FIXED_LIBNAME "Use a non-versioned name for the library and no symbolic linking to variant names" OFF)
-
-set(LIBNAMEPREFIX "" CACHE STRING  "Add a prefix to the openblas part of the library name" )
-set(LIBNAMESUFFIX "" CACHE STRING  "Add a suffix after the openblas part of the library name" )
-
 if(${CMAKE_SYSTEM_NAME} MATCHES "Linux")
   option(NO_AFFINITY "Disable support for CPU affinity masks to avoid binding processes from e.g. R or numpy/scipy to a single core" ON)
 else()
   set(NO_AFFINITY 1)
 endif()
 
-option(CPP_THREAD_SAFETY_TEST "Run massively parallel DGEMM tests to confirm thread safety of the library (requires about 1.3GB of RAM)" OFF)
-option(CPP_THREAD_SAFETY_USE_OPENMP "Use OpenMP to launch the C++ thread safety tests" ON)
+option(CPP_THREAD_SAFETY_TEST "Run a massively parallel DGEMM test to confirm thread safety of the library (requires OpenMP and about 1.3GB of RAM)" OFF)
 
-option(CPP_THREAD_SAFETY_GEMV "Run a massively parallel DGEMV test to confirm thread safety of the library" OFF)
+option(CPP_THREAD_SAFETY_GEMV "Run a massively parallel DGEMV test to confirm thread safety of the library (requires OpenMP)" OFF)
 option(BUILD_STATIC_LIBS "Build static library" OFF)
-option(BUILD_SHARED_LIBS "Build shared library" OFF)
 if(NOT BUILD_STATIC_LIBS AND NOT BUILD_SHARED_LIBS)
   set(BUILD_STATIC_LIBS ON CACHE BOOL "Build static library" FORCE)
 endif()
@@ -79,27 +61,12 @@ set(SYMBOLPREFIX "" CACHE STRING  "Add a prefix to all exported symbol names in
 
 set(SYMBOLSUFFIX "" CACHE STRING  "Add a suffix to all exported symbol names in the shared library, e.g. _64 for INTERFACE64 builds" )
 
-if (CMAKE_SYSTEM_NAME MATCHES "Windows" AND BUILD_SHARED_LIBS AND NOT ("${SYMBOLPREFIX}${SYMBOLSUFFIX}" STREQUAL ""))
-set (DELETE_STATIC_LIBS "")
-if (NOT BUILD_STATIC_LIBS)
-	message (STATUS "forcing build of a temporary static library for symbol renaming")
-	set (BUILD_SHARED_LIBS OFF CACHE BOOL "Build shared library" FORCE)
-	set (BUILD_STATIC_LIBS ON CACHE BOOL "Build static library" FORCE)
-	set (DELETE_STATIC_LIBS  file (REMOVE $<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.lib))
-endif ()
-endif()
-
-
 #######
 if(BUILD_WITHOUT_LAPACK)
   set(NO_LAPACK 1)
   set(NO_LAPACKE 1)
 endif()
 
-if (BUILD_WITHOUT_LAPACKE)
-  set(NO_LAPACKE 1)
-endif()
-
 if(BUILD_WITHOUT_CBLAS)
   set(NO_CBLAS 1)
 endif()
@@ -125,12 +92,7 @@ message(WARNING "CMake support is experimental. It does not yet support all buil
 include("${PROJECT_SOURCE_DIR}/cmake/utils.cmake")
 include("${PROJECT_SOURCE_DIR}/cmake/system.cmake")
 
-string(FIND "${LIBNAMESUFFIX}" "${SUFFIX64_UNDERSCORE}" HAVE64)
-if (${HAVE64} GREATER -1)
-	set(OpenBLAS_LIBNAME ${LIBNAMEPREFIX}openblas${LIBNAMESUFFIX})
-else ()
-	set(OpenBLAS_LIBNAME ${LIBNAMEPREFIX}openblas${LIBNAMESUFFIX}${SUFFIX64_UNDERSCORE})
-endif ()
+set(OpenBLAS_LIBNAME openblas${SUFFIX64_UNDERSCORE})
 
 set(BLASDIRS interface driver/level2 driver/level3 driver/others)
 
@@ -153,9 +115,6 @@ endif ()
 if (NOT DEFINED BUILD_BFLOAT16)
  set (BUILD_BFLOAT16 false)
 endif ()
-if (NOT DEFINED BUILD_HFLOAT16)
- set (BUILD_HFLOAT16 false)
-endif ()
 # set which float types we want to build for
 if (NOT DEFINED BUILD_SINGLE AND NOT DEFINED BUILD_DOUBLE AND NOT DEFINED BUILD_COMPLEX AND NOT DEFINED BUILD_COMPLEX16)
   # if none are defined, build for all
@@ -220,7 +179,7 @@ endforeach ()
 
 # Can't just use lapack-netlib's CMake files, since they are set up to search for BLAS, build and install a binary. We just want to build a couple of lib files out of lapack and lapacke.
 # Not using add_subdirectory here because lapack-netlib already has its own CMakeLists.txt. Instead include a cmake script with the sources we want.
-if (NOT NO_LAPACK)
+if (NOT NOFORTRAN AND NOT NO_LAPACK)
   include("${PROJECT_SOURCE_DIR}/cmake/lapack.cmake")
   if (NOT NO_LAPACKE)
     include("${PROJECT_SOURCE_DIR}/cmake/lapacke.cmake")
@@ -244,57 +203,19 @@ if (${DYNAMIC_ARCH})
   endforeach()
 endif ()
 
-# Work around Apple issue with "argument list too long" when linking.
-# Seen for DYNAMIC_ARCH when there are a _LOT_ of variants build, previously
-# mostly with older versions on POWERPC or Intel CPUs, but with newer ARM
-# CPUs and newer compilers this will also occur on ARM.
-#
-# This must happen before the add_library() calls, otherwise this will have
-# no effect.
-#
-# Unfortunately, while this workaround will work for shared libraries (with
-# either Ninja oder Unix Makefiles), but not for static libraries, as ar
-# does not accept response files. So for the case where we (also) build
-# static libraries we need an additional workaround, see below. (The
-# generation of the response files by CMake must still be enabled, so this
-# is required regardless.)
-if(APPLE)
-  set(CMAKE_C_USE_RESPONSE_FILE_FOR_OBJECTS ON)
-  set(CMAKE_C_USE_RESPONSE_FILE_FOR_LIBRARIES ON)
-  if(NOT NOFORTRAN)
-    set(CMAKE_Fortran_USE_RESPONSE_FILE_FOR_OBJECTS ON)
-    set(CMAKE_Fortran_USE_RESPONSE_FILE_FOR_LIBRARIES ON)
-    # NAG Fortran does not support the GCC-specific -x f95-cpp-input flag
-    # used in the shared library link rule below.  Override
-    # CMAKE_Fortran_CREATE_SHARED_LIBRARY early (before targets are defined)
-    # to use the C compiler link rule instead; the shared library contains
-    # only C and assembler objects so this is safe.
-    if(CMAKE_Fortran_COMPILER_ID MATCHES "NAG")
-      set(CMAKE_Fortran_CREATE_SHARED_LIBRARY ${CMAKE_C_CREATE_SHARED_LIBRARY})
-    endif()
-  endif()
-  set(CMAKE_NINJA_FORCE_RESPONSE_FILE ON)
-endif()
-
 # add objects to the openblas lib
 if(NOT NO_LAPACK)
-  add_library(LAPACK_OVERRIDES OBJECT ${LA_SOURCES})
-  if (USE_OPENMP AND (NOT NOFORTRAN))
-    # Disable OpenMP for LAPACK Fortran codes on Windows.
-    if(NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-      target_link_libraries(LAPACK_OVERRIDES OpenMP::OpenMP_Fortran)
-    endif()
-  endif()
-  list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:LAPACK_OVERRIDES>")
+  add_library(LAPACK OBJECT ${LA_SOURCES})
+  list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:LAPACK>")
 endif()
 if(NOT NO_LAPACKE)
   add_library(LAPACKE OBJECT ${LAPACKE_SOURCES})
   list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:LAPACKE>")
 endif()
-#if(BUILD_RELAPACK)
-#  add_library(RELAPACK OBJECT ${RELA_SOURCES})
-#  list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:RELAPACK>")
-#endif()
+if(BUILD_RELAPACK)
+  add_library(RELAPACK OBJECT ${RELA_SOURCES})
+  list(APPEND TARGET_OBJS "$<TARGET_OBJECTS:RELAPACK>")
+endif()
 set(OpenBLAS_LIBS "")
 if(BUILD_STATIC_LIBS)
   add_library(${OpenBLAS_LIBNAME}_static STATIC ${TARGET_OBJS} ${OpenBLAS_DEF_FILE})
@@ -315,7 +236,7 @@ endif()
 set_target_properties(${OpenBLAS_LIBS} PROPERTIES OUTPUT_NAME ${OpenBLAS_LIBNAME})
 
 # Android needs to explicitly link against libm
-if (${CMAKE_SYSTEM_NAME} MATCHES "AIX|Android|Linux|FreeBSD|OpenBSD|NetBSD|DragonFly|Darwin")
+if(ANDROID)
   if(BUILD_STATIC_LIBS)
     target_link_libraries(${OpenBLAS_LIBNAME}_static m)
   endif()
@@ -324,85 +245,22 @@ if (${CMAKE_SYSTEM_NAME} MATCHES "AIX|Android|Linux|FreeBSD|OpenBSD|NetBSD|Drago
   endif()
 endif()
 
-if (USE_OPENMP)
-  if(BUILD_STATIC_LIBS)
-    if(NOFORTRAN)
-      target_link_libraries(${OpenBLAS_LIBNAME}_static OpenMP::OpenMP_C)
-    else()
-      target_link_libraries(${OpenBLAS_LIBNAME}_static OpenMP::OpenMP_C OpenMP::OpenMP_Fortran)
-    endif()
-  endif()
-  if(BUILD_SHARED_LIBS)
-    if(NOFORTRAN)
-      target_link_libraries(${OpenBLAS_LIBNAME}_shared OpenMP::OpenMP_C)
-    else()
-      target_link_libraries(${OpenBLAS_LIBNAME}_shared OpenMP::OpenMP_C OpenMP::OpenMP_Fortran)
-    endif()
-  endif()
-endif()
-
-# Second part of "Argument list too long" fix when static libraries are
-# built. See above for details.
-if(APPLE AND BUILD_STATIC_LIBS)
-  # Always build static library first
-  set(STATIC_PATH "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/lib${OpenBLAS_LIBNAME}.a")
-  # Handle differences in how many response files are generated and/or where
-  # they are stored for Ninja / Unix Makefiles.
-  if("${CMAKE_GENERATOR}" MATCHES "Ninja")
-    set(CREATE_STATIC_LIBRARY_COMMAND
-      "sh -c 'cat ${CMAKE_BINARY_DIR}/CMakeFiles/openblas_static.rsp | xargs -n 1024 ${CMAKE_AR} -ru ${STATIC_PATH} && exit 0' "
-      "sh -c '${CMAKE_AR} -rs ${STATIC_PATH} ${CMAKE_BINARY_DIR}/driver/others/CMakeFiles/driver_others.dir/xerbla.c.o && exit 0' ")
-  else()
-    set(CREATE_STATIC_LIBRARY_COMMAND
-      "sh -c 'cat ${CMAKE_BINARY_DIR}/CMakeFiles/${OpenBLAS_LIBNAME}_static.dir/objects*.rsp | xargs -n 1024 ${CMAKE_AR} -ru ${STATIC_PATH} && exit 0' "
-      "sh -c '${CMAKE_AR} -rs ${STATIC_PATH} ${CMAKE_BINARY_DIR}/driver/others/CMakeFiles/driver_others.dir/xerbla.c.o && exit 0' ")
-  endif()
-  if(BUILD_SHARED_LIBS)
-    add_dependencies(${OpenBLAS_LIBNAME}_shared ${OpenBLAS_LIBNAME}_static)
-    set(SHARED_PATH "${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libopenblas.${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.dylib")
-  endif()
-  if(USE_OPENMP)
-    get_target_property(OMP_LIB OpenMP::OpenMP_C INTERFACE_LINK_LIBRARIES)
-  else()
-    set(OMP_LIB "")
-  endif()
-  if(NOT NOFORTRAN)
-    set(CMAKE_Fortran_CREATE_STATIC_LIBRARY ${CREATE_STATIC_LIBRARY_COMMAND})
-    if(BUILD_SHARED_LIBS)
-      if(CMAKE_Fortran_COMPILER_ID MATCHES "GNU")
-        set(CMAKE_Fortran_CREATE_SHARED_LIBRARY
-          "sh -c 'echo \"\" | ${CMAKE_Fortran_COMPILER} -o dummy.o -c -x f95-cpp-input - '"
-          "sh -c '${CMAKE_Fortran_COMPILER} -fpic -shared -Wl,-all_load -Wl,-force_load,${STATIC_PATH} dummy.o -o ${SHARED_PATH} ${OMP_LIB}'")
-      elseif(CMAKE_Fortran_COMPILER_ID MATCHES "NAG")
-        # NAG does not support -x f95-cpp-input, and macOS needs -dynamiclib
-        # rather than -Wl,-shared.  Use the C compiler as the linker driver
-        # and add the NAG Fortran runtime so NAGf90_* symbols resolve.
-        # Locate the NAG Fortran runtime (libf<XY>rts) without hardcoding the
-        # version digits: NAG 7.1 ships libf71rts, 7.2 ships libf72rts, etc.
-        get_filename_component(_NAG_FC_DIR "${CMAKE_Fortran_COMPILER}" DIRECTORY)
-        set(_NAG_RTS_DIR "${_NAG_FC_DIR}/../lib/NAG_Fortran")
-        file(GLOB _NAG_RTS_CANDIDATES
-             "${_NAG_RTS_DIR}/libf*rts.dylib"
-             "${_NAG_RTS_DIR}/libf*rts.a")
-        if(_NAG_RTS_CANDIDATES)
-          list(GET _NAG_RTS_CANDIDATES 0 _NAG_RTS_LIB)
-          get_filename_component(_NAG_RTS_NAME "${_NAG_RTS_LIB}" NAME_WE)
-          string(REGEX REPLACE "^lib" "" _NAG_RTS_LIBNAME "${_NAG_RTS_NAME}")
-          set(_NAG_RTS_FLAGS "-L${_NAG_RTS_DIR} -l${_NAG_RTS_LIBNAME}")
-        else()
-          set(_NAG_RTS_FLAGS "")
-        endif()
-        set(CMAKE_Fortran_CREATE_SHARED_LIBRARY
-          "sh -c '${CMAKE_C_COMPILER} -dynamiclib -Wl,-all_load -Wl,-force_load,${STATIC_PATH} -o ${SHARED_PATH} ${OMP_LIB} ${_NAG_RTS_FLAGS}'")
-      endif()
-    endif()
-  else()
-    set(CMAKE_C_CREATE_STATIC_LIBRARY ${CREATE_STATIC_LIBRARY_COMMAND})
-    if(BUILD_SHARED_LIBS)
-      set(CMAKE_C_CREATE_SHARED_LIBRARY
-	"sh -c '${CMAKE_C_COMPILER} -fpic -shared -Wl,-all_load -Wl,-force_load,${STATIC_PATH} -o ${SHARED_PATH} ${OMP_LIB}'")
-    endif()
-  endif()
+if (APPLE AND DYNAMIC_ARCH AND BUILD_SHARED_LIBS)
+  set (CMAKE_C_USE_RESPONSE_FILE_FOR_OBJECTS 1)
+  if (NOT NOFORTRAN)  
+  set (CMAKE_Fortran_USE_RESPONSE_FILE_FOR_OBJECTS 1)
+  set (CMAKE_Fortran_CREATE_SHARED_LIBRARY
+ "sh -c 'cat ${CMAKE_BINARY_DIR}/CMakeFiles/openblas_shared.dir/objects*.rsp | xargs -n 1024 ar -ru libopenblas.a && exit 0' "
+ "sh -c 'ar -ru libopenblas.a ${CMAKE_BINARY_DIR}/driver/others/CMakeFiles/driver_others.dir/xerbla.c.o && exit 0' "
+ "sh -c 'echo \"\" | ${CMAKE_Fortran_COMPILER} -o dummy.o -c -x f95-cpp-input - '"
+ "sh -c '${CMAKE_Fortran_COMPILER} -fpic -shared -Wl,-all_load -Wl,-force_load,libopenblas.a -Wl,-noall_load dummy.o -o ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libopenblas.${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.dylib'"
+ "sh -c 'ls -l ${CMAKE_BINARY_DIR}/lib'")
+  else ()
+  set (CMAKE_C_CREATE_SHARED_LIBRARY
+   "sh -c 'cat ${CMAKE_BINARY_DIR}/CMakeFiles/openblas_shared.dir/objects*.rsp | xargs -n 1024 ar -ru libopenblas.a && exit 0' "
+   "sh -c 'ar -ru libopenblas.a ${CMAKE_BINARY_DIR}/driver/others/CMakeFiles/driver_others.dir/xerbla.c.o && exit 0' "
+   "sh -c '${CMAKE_C_COMPILER} -fpic -shared -Wl,-all_load -Wl,-force_load,libopenblas.a -Wl,-noall_load -o ${CMAKE_LIBRARY_OUTPUT_DIRECTORY}/libopenblas.${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}.dylib'")
+  endif ()
 endif()
 
 # Handle MSVC exports
@@ -449,36 +307,27 @@ endif()
 
 #if (MSVC OR NOT NOFORTRAN)
 if (NOT NO_CBLAS)
-  if (NOT ONLY_CBLAS)
   # Broken without fortran on unix
-    add_subdirectory(utest)
-endif()
+  add_subdirectory(utest)
 endif()
 
 if (NOT NOFORTRAN)
- if (NOT ONLY_CBLAS)
   # Build test and ctest
   add_subdirectory(test)
- endif()
- if (BUILD_TESTING AND NOT BUILD_WITHOUT_LAPACK)
-    add_subdirectory(lapack-netlib/TESTING)
-  endif()
-endif()
   if(NOT NO_CBLAS)
-   if (NOT ONLY_CBLAS)
     add_subdirectory(ctest)
-   endif()
   endif()
+  add_subdirectory(lapack-netlib/TESTING)
   if (CPP_THREAD_SAFETY_TEST OR CPP_THREAD_SAFETY_GEMV)
     add_subdirectory(cpp_thread_test)
   endif()
+endif()
 
-if (NOT FIXED_LIBNAME)
 set_target_properties(${OpenBLAS_LIBS} PROPERTIES
   VERSION ${OpenBLAS_MAJOR_VERSION}.${OpenBLAS_MINOR_VERSION}
   SOVERSION ${OpenBLAS_MAJOR_VERSION}
 )
-endif()
+
 if (BUILD_SHARED_LIBS AND BUILD_RELAPACK)
   if (NOT MSVC)
     target_link_libraries(${OpenBLAS_LIBNAME}_shared "-Wl,-allow-multiple-definition")
@@ -487,7 +336,7 @@ if (BUILD_SHARED_LIBS AND BUILD_RELAPACK)
   endif()
 endif()
 
-if (BUILD_SHARED_LIBS OR DELETE_STATIC_LIBS AND NOT ${SYMBOLPREFIX}${SYMBOLSUFFIX} STREQUAL "")
+if (BUILD_SHARED_LIBS AND NOT ${SYMBOLPREFIX}${SYMBOLSUFFIX} STREQUAL "")
   if (NOT DEFINED ARCH)
     set(ARCH_IN "x86_64")
   else()
@@ -545,134 +394,11 @@ if (BUILD_SHARED_LIBS OR DELETE_STATIC_LIBS AND NOT ${SYMBOLPREFIX}${SYMBOLSUFFI
     message(STATUS "adding suffix ${SYMBOLSUFFIX} to names of exported symbols in ${OpenBLAS_LIBNAME}")
   endif()
 
-  if (${BUILD_LAPACK_DEPRECATED})
-	  set (BLD 1)
-  else ()
-	  set (BLD 0)
-  endif()
-  if (${BUILD_BFLOAT16})
-	  set (BBF16 1)
-  else ()
-	  set (BBF16 0)
-  endif()
-  if (${BUILD_HFLOAT16})
-	  set (BHF16 1)
-  else ()
-	  set (BHF16 0)
-  endif()
-  if (${BUILD_SINGLE})
-	  set (BS 1)
-  else ()
-	  set (BS 0)
-  endif()
-  if (${BUILD_DOUBLE})
-	  set (BD 1)
-  else ()
-	  set (BD 0)
-  endif()
-  if (${BUILD_COMPLEX})
-	  set (BC 1)
-  else ()
-	  set (BC 0)
-  endif()
-  if (${BUILD_COMPLEX16})
-	  set (BZ 1)
-  else ()
-	  set (BZ 0)
-  endif()
-
-  if (CMAKE_SYSTEM_NAME MATCHES "Windows")
-set(CMAKE_LIBRARY_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
-set(CMAKE_ARCHIVE_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
-if (CMAKE_BUILD_TYPE MATCHES "Debug")
-set (CRTLIB msvcrtd)
-set (PDBOPT -debug -pdb:$<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.pdb)
-set (PDB_OUTPUT_DIRECTORY ${PROJECT_BINARY_DIR}/lib)
-else ()
-set (CRTLIB msvcrt)
-set (PDBOPT "")
-endif()
- #if (USE_PERL)
-message(STATUS "adding postbuild instruction to rename syms")
-  add_custom_command(TARGET ${OpenBLAS_LIBNAME}_static POST_BUILD
-	COMMAND perl ${PROJECT_SOURCE_DIR}/exports/gensymbol.pl "win2k" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" "${SYMBOLPREFIX}" "${SYMBOLSUFFIX}" "${BLD}" "${BBF16}" "${BHF16}" "${BS}" "${BD}" "${BC}" "${BZ}" > ${PROJECT_BINARY_DIR}/renamesyms.def
-	COMMAND ${CMAKE_C_COMPILER} ${CMAKE_C_FLAGS} -I${PROJECT_SOURCE_DIR} -I${PROJECT_BINARY_DIR} -c -o ${PROJECT_BINARY_DIR}/dllinit.o ${PROJECT_SOURCE_DIR}/exports/dllinit.c
-	COMMAND lld-link -nodefaultlib:libcmt -defaultlib:${CRTLIB} ${CMAKE_LINKER_FLAGS} -errorlimit:0 -def:${PROJECT_BINARY_DIR}/renamesyms.def ${PROJECT_BINARY_DIR}/dllinit.o $<TARGET_FILE:${OpenBLAS_LIBNAME}_static> -wholearchive:$<TARGET_FILE:${OpenBLAS_LIBNAME}_static> -dll -out:$<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.dll -implib:$<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.dll.a ${PDBOPT} 
-	#COMMAND lld-link -nodefaultlib:libcmt -defaultlib:msvcrt ${CMAKE_LINKER_FLAGS} -errorlimit:0 -def:${PROJECT_BINARY_DIR}/renamesyms.def ${PROJECT_BINARY_DIR}/dllinit.o $<TARGET_FILE:${OpenBLAS_LIBNAME}_static> -wholearchive:$<TARGET_FILE:${OpenBLAS_LIBNAME}_static> -dll -out:$<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.dll -implib:$<TARGET_FILE_DIR:${OpenBLAS_LIBNAME}_static>/${OpenBLAS_LIBNAME}.dll.a
-	 ${REMOVE_STATIC_LIB} VERBATIM
-  )
-  #endif ()
-  else ()
-  if (NOT USE_PERL)
   add_custom_command(TARGET ${OpenBLAS_LIBNAME}_shared POST_BUILD
-	  COMMAND sh ${PROJECT_SOURCE_DIR}/exports/gensymbol "objcopy" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" \"${SYMBOLPREFIX}\" \"${SYMBOLSUFFIX}\" "${BLD}" "${BBF16}" "${BHF16}" "${BS}" "${BD}" "${BC}" "${BZ}" > ${PROJECT_BINARY_DIR}/objcopy.def
-    COMMAND objcopy --redefine-syms ${PROJECT_BINARY_DIR}/objcopy.def  ${PROJECT_BINARY_DIR}/lib/${OpenBLAS_LIBNAME}.so
+    COMMAND perl  ${PROJECT_SOURCE_DIR}/exports/gensymbol "objcopy" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" \"${SYMBOLPREFIX}\" \"${SYMBOLSUFFIX}\" "${BUILD_LAPACK_DEPRECATED}" > ${PROJECT_BINARY_DIR}/objcopy.def
+    COMMAND objcopy -v --redefine-syms ${PROJECT_BINARY_DIR}/objcopy.def  ${PROJECT_BINARY_DIR}/lib/lib${OpenBLAS_LIBNAME}.so
     COMMENT "renaming symbols"
     )
-  else()
-  add_custom_command(TARGET ${OpenBLAS_LIBNAME}_shared POST_BUILD
-    COMMAND perl ${PROJECT_SOURCE_DIR}/exports/gensymbol.pl "objcopy" "${ARCH}" "${BU}" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" \"${SYMBOLPREFIX}\" \"${SYMBOLSUFFIX}\" "${BLD}" "${BBF16}" "${BHF16}" "${BS}" "${BD}" "${BC}" "${BZ}" > ${PROJECT_BINARY_DIR}/objcopy.def
-    COMMAND objcopy --redefine-syms ${PROJECT_BINARY_DIR}/objcopy.def  ${PROJECT_BINARY_DIR}/lib/lib${OpenBLAS_LIBNAME}.so
-    COMMENT "renaming symbols"
-    )
-  endif()
-endif()
-endif()
-
-if (BUILD_BENCHMARKS)
-	#find_package(OpenMP REQUIRED)
-  file(GLOB SOURCES "benchmark/*.c")
-  if (NOT USE_OPENMP)
-  file(GLOB REMFILE "benchmark/smallscaling.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  endif()
-  if (BUILD_WITHOUT_LAPACK)
-  file(GLOB REMFILE "benchmark/cholesky.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  file(GLOB REMFILE "benchmark/geev.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  file(GLOB REMFILE "benchmark/gesv.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  file(GLOB REMFILE "benchmark/getri.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  file(GLOB REMFILE "benchmark/potrf.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  file(GLOB REMFILE "benchmark/spmv.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  file(GLOB REMFILE "benchmark/symv.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  file(GLOB REMFILE "benchmark/linpack.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  endif()
-  if (NOT USE_GEMM3M)
-  file(GLOB REMFILE "benchmark/gemm3m.c")
-  list(REMOVE_ITEM SOURCES ${REMFILE})
-  endif()
-  foreach(source ${SOURCES})
-    get_filename_component(name ${source} NAME_WE)
-    if ((NOT ${name} STREQUAL "zdot-intel") AND (NOT ${name} STREQUAL "cula_wrapper"))
-        set(defines DEFAULT COMPLEX DOUBLE "COMPLEX\;DOUBLE")
-      foreach(define ${defines})
-        set(target_name "benchmark_${name}")
-        if (NOT "${define}" STREQUAL "DEFAULT")
-          string(JOIN "_" define_str ${define})
-          set(target_name "${target_name}_${define_str}")
-        endif()
-        if ((NOT ${target_name} STREQUAL "benchmark_imax_COMPLEX") AND (NOT ${target_name} STREQUAL "benchmark_imax_COMPLEX_DOUBLE") AND
-            (NOT ${target_name} STREQUAL "benchmark_imin_COMPLEX") AND (NOT ${target_name} STREQUAL "benchmark_imin_COMPLEX_DOUBLE") AND
-            (NOT ${target_name} STREQUAL "benchmark_max_COMPLEX") AND (NOT ${target_name} STREQUAL "benchmark_max_COMPLEX_DOUBLE") AND
-            (NOT ${target_name} STREQUAL "benchmark_min_COMPLEX") AND (NOT ${target_name} STREQUAL "benchmark_min_COMPLEX_DOUBLE"))
-          add_executable(${target_name} ${source})
-          target_include_directories(${target_name} PRIVATE ${CMAKE_CURRENT_SOURCE_DIR} ${CMAKE_CURRENT_BINARY_DIR})
-	    target_link_libraries(${target_name} ${OpenBLAS_LIBNAME} )
-	  #  target_link_libraries(${target_name} ${OpenBLAS_LIBNAME} OpenMP::OpenMP_C)
-          if (NOT "${define}" STREQUAL "DEFAULT")
-            target_compile_definitions(${target_name} PRIVATE ${define})
-          endif()
-        endif()
-      endforeach()
-    endif()
-  endforeach()
 endif()
 
 
@@ -733,48 +459,19 @@ if(NOT NO_CBLAS)
   message (STATUS "Generating cblas.h in ${CMAKE_INSTALL_INCLUDEDIR}")
   set(CBLAS_H ${CMAKE_BINARY_DIR}/generated/cblas.h)
   file(READ ${CMAKE_CURRENT_SOURCE_DIR}/cblas.h CBLAS_H_CONTENTS)
-  string(REPLACE "common" "openblas_config" CBLAS_H_CONTENTS_NEW2 "${CBLAS_H_CONTENTS}")
-  string(REPLACE "OPENBLAS_EXPORT " "" CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW2}")
-
-  # Symbol prefix/suffix settings rename exported functions, not C typedefs.
-  # Protect callback type names from the textual function-name rewriting below.
-  string(REPLACE "openblas_dojob_callback" "OPENBLAS_DOJOB_CALLBACK_TYPE"
-    CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-  string(REPLACE "openblas_threads_callback" "OPENBLAS_THREADS_CALLBACK_TYPE"
-    CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-  string(REPLACE "openblas_xerbla_handler" "OPENBLAS_XERBLA_HANDLER_TYPE"
-    CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-
+  string(REPLACE "common" "openblas_config" CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS}")
   if (NOT ${SYMBOLPREFIX} STREQUAL "")
-    string(REPLACE " cblas" " ${SYMBOLPREFIX}cblas"
-      CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-    string(REPLACE " openblas" " ${SYMBOLPREFIX}openblas"
-      CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-    string(REPLACE " ${SYMBOLPREFIX}openblas_complex" " openblas_complex"
-      CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-    string(REPLACE " goto" " ${SYMBOLPREFIX}goto"
-      CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
+    string(REPLACE " cblas" " ${SYMBOLPREFIX}cblas" CBLAS_H_CONTENTS	"${CBLAS_H_CONTENTS_NEW}")
+    string(REPLACE " openblas" " ${SYMBOLPREFIX}openblas" CBLAS_H_CONTENTS_NEW	"${CBLAS_H_CONTENTS}")
+    string (REPLACE " ${SYMBOLPREFIX}openblas_complex" " openblas_complex" CBLAS_H_CONTENTS	"${CBLAS_H_CONTENTS_NEW}")
+    string(REPLACE " goto" " ${SYMBOLPREFIX}goto" CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS}")
   endif()
   if (NOT ${SYMBOLSUFFIX} STREQUAL "")
-    string(REGEX REPLACE "(cblas[A-Za-z0-9_]*)" "\\1${SYMBOLSUFFIX}"
-      CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-    string(REGEX REPLACE "(openblas[A-Za-z0-9_]*)" "\\1${SYMBOLSUFFIX}"
-      CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-    string(REPLACE "openblas_config${SYMBOLSUFFIX}" "openblas_config"
-      CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-    string(REGEX REPLACE "(openblas_complex[A-Za-z0-9_]*)${SYMBOLSUFFIX}" "\\1"
-      CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-    string(REGEX REPLACE "(goto[A-Za-z0-9_]*)" "\\1${SYMBOLSUFFIX}"
-      CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
+    string(REGEX REPLACE "(cblas[^ (]*)" "\\1${SYMBOLSUFFIX}" CBLAS_H_CONTENTS	"${CBLAS_H_CONTENTS_NEW}")
+    string(REGEX REPLACE "(openblas[^ (]*)" "\\1${SYMBOLSUFFIX}" CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS}")
+    string(REGEX REPLACE "(openblas_complex[^ ]*)${SYMBOLSUFFIX}" "\\1" CBLAS_H_CONTENTS	"${CBLAS_H_CONTENTS_NEW}")
+    string(REGEX REPLACE "(goto[^ (]*)" "\\1${SYMBOLSUFFIX}" CBLAS_H_CONTENTS_NEW	"${CBLAS_H_CONTENTS}")
   endif()
-
-  string(REPLACE "OPENBLAS_DOJOB_CALLBACK_TYPE" "openblas_dojob_callback"
-    CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-  string(REPLACE "OPENBLAS_THREADS_CALLBACK_TYPE" "openblas_threads_callback"
-    CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-  string(REPLACE "OPENBLAS_XERBLA_HANDLER_TYPE" "openblas_xerbla_handler"
-    CBLAS_H_CONTENTS_NEW "${CBLAS_H_CONTENTS_NEW}")
-
   file(WRITE ${CBLAS_H} "${CBLAS_H_CONTENTS_NEW}")
   install (FILES ${CBLAS_H} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
 endif()
@@ -793,40 +490,7 @@ if(NOT NO_LAPACKE)
   ADD_CUSTOM_TARGET(genlapacke
   COMMAND ${CMAKE_COMMAND} -E copy ${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/include/lapacke_mangling_with_flags.h.in "${CMAKE_BINARY_DIR}/lapacke_mangling.h"
   )
-  install (FILES ${CMAKE_BINARY_DIR}/lapacke_mangling.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-  if (NOT (x${SYMBOLPREFIX}${SYMBOLSUFFIX} STREQUAL "x"))
-  message (STATUS "Generating lapacke.h in ${CMAKE_INSTALL_INCLUDEDIR}")
-  set(LAPACKE_H ${CMAKE_BINARY_DIR}/generated/lapacke.h)
-  file(READ ${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/include/lapacke.h LAPACKE_H_CONTENTS)
-  if (NOT ${SYMBOLPREFIX} STREQUAL "")
-	  string(REGEX REPLACE "(LAPACKE_*)" " ${SYMBOLPREFIX}\\1" LAPACKE_H_CONTENTS_NEW	"${LAPACKE_H_CONTENTS}")
-	  string(REPLACE "_ ${SYMBOLPREFIX}LAPACKE_H_"  "_LAPACKE_H_" LAPACKE_H_CONTENTS ${LAPACKE_H_CONTENTS_NEW})
-	  string(REPLACE "${SYMBOLPREFIX}LAPACKE_malloc"  "LAPACKE_malloc" LAPACKE_H_CONTENTS_NEW ${LAPACKE_H_CONTENTS})
-	  string(REPLACE "${SYMBOLPREFIX}LAPACKE_free"  "LAPACKE_free" LAPACKE_H_CONTENTS ${LAPACKE_H_CONTENTS_NEW})
-	  set(LAPACKE_H_CONTENTS_NEW ${LAPACKE_H_CONTENTS})
-  endif()
-  if (NOT ${SYMBOLSUFFIX} STREQUAL "")
-	  string(REGEX REPLACE "(${SYMBOLPREFIX}LAPACKE_[a-z1-9]*[^ (]*)" "\\1${SYMBOLSUFFIX}" LAPACKE_H_CONTENTS_NEW	"${LAPACKE_H_CONTENTS}")
-	  string(REPLACE "#define${SYMBOLSUFFIX}"  "#define" LAPACKE_H_CONTENTS ${LAPACKE_H_CONTENTS_NEW})
-	  string(REPLACE "LAPACKE_malloc${SYMBOLSUFFIX}"  "LAPACKE_malloc" LAPACKE_H_CONTENTS_NEW ${LAPACKE_H_CONTENTS})
-	  string(REPLACE "LAPACKE_free${SYMBOLSUFFIX}"  "LAPACKE_free" LAPACKE_H_CONTENTS ${LAPACKE_H_CONTENTS_NEW})
-	  set(LAPACKE_H_CONTENTS_NEW ${LAPACKE_H_CONTENTS})
-  endif()
-  file(WRITE ${LAPACKE_H} "${LAPACKE_H_CONTENTS_NEW}")
-  install (FILES ${LAPACKE_H} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-  message (STATUS "Generating lapack.h in ${CMAKE_INSTALL_INCLUDEDIR}")
-  set(LAPACK_H ${CMAKE_BINARY_DIR}/generated/lapack.h)
-  file(READ ${CMAKE_CURRENT_SOURCE_DIR}/lapack-netlib/LAPACKE/include/lapack.h LAPACK_H_CONTENTS)
-  if (NOT ${SYMBOLPREFIX} STREQUAL "")
-	  string(REGEX REPLACE "(LAPACK_[a-z1-9]*[ \(][.\)]*)" "${SYMBOLPREFIX}\\1" LAPACK_H_CONTENTS_NEW	"${LAPACK_H_CONTENTS}")
-	  set(LAPACK_H_CONTENTS ${LAPACK_H_CONTENTS_NEW})
-  endif()
-  if (NOT ${SYMBOLSUFFIX} STREQUAL "")
-	  string(REGEX REPLACE "(${SYMBOLPREFIX}LAPACK_[a-z1-9]*)([ \(].\)" "\\1${SYMBOLSUFFIX}\\2" LAPACK_H_CONTENTS_NEW	"${LAPACK_H_CONTENTS}")
-  endif()
-  file(WRITE ${LAPACK_H} "${LAPACK_H_CONTENTS_NEW}")
-  install (FILES ${LAPACK_H} DESTINATION ${CMAKE_INSTALL_INCLUDEDIR})
-endif()
+  install (FILES ${CMAKE_BINARY_DIR}/lapacke_mangling.h DESTINATION ${CMAKE_INSTALL_INCLUDEDIR}/openblas${SUFFIX64})
 endif()
 
 # Install pkg-config files
@@ -834,8 +498,9 @@ configure_file(${PROJECT_SOURCE_DIR}/cmake/openblas.pc.in ${PROJECT_BINARY_DIR}/
 install (FILES ${PROJECT_BINARY_DIR}/openblas${SUFFIX64}.pc DESTINATION ${CMAKE_INSTALL_LIBDIR}/pkgconfig/)
 
 
+# GNUInstallDirs "DATADIR" wrong here; CMake search path wants "share".
 set(PN OpenBLAS)
-set(CMAKECONFIG_INSTALL_DIR "${CMAKE_INSTALL_LIBDIR}/cmake/${PN}${SUFFIX64}")
+set(CMAKECONFIG_INSTALL_DIR "share/cmake/${PN}${SUFFIX64}")
 configure_package_config_file(cmake/${PN}Config.cmake.in
                               "${CMAKE_CURRENT_BINARY_DIR}/${PN}${SUFFIX64}Config.cmake"
                               INSTALL_DESTINATION ${CMAKECONFIG_INSTALL_DIR})

CONTRIBUTORS.md

@@ -23,15 +23,6 @@
   * Optimization on AMD Piledriver
   * Optimization on Intel Haswell
 
-* Chris Sidebottom <chris.sidebottom@arm.com>
-  * Optimizations and other improvements targeting AArch64
-
-* Annop Wongwathanarat <annop.wongwathanarat@arm.com>
-  * Optimizations and other improvements targeting AArch64
-
-* Anna Mayne <anna.mayne@arm.com>
-  * Optimizations and other improvements targeting AArch64
-
 ## Previous Developers
 
 * Zaheer Chothia <zaheer.chothia@gmail.com>
@@ -204,9 +195,6 @@ In chronological order:
 * PingTouGe Semiconductor Co., Ltd.
   * [2020-10] Add RISC-V Vector (0.7.1) support. Optimize BLAS kernels for Xuantie C910
 
-* Jake Arkinstall <https://github.com/jake-arkinstall>
-  * [2021-02-10] Remove in-source configure_file to enable builds in read-only contexts (issue #3100, PR #3101)
-
 * River Dillon <oss@outerpassage.net>
   * [2021-07-10] fix compilation with musl libc
 
@@ -216,75 +204,3 @@ In chronological order:
   * [2021-11-12] SVE kernels for SGEMM, STRMM and corresponding SVE copy functions
   * [2022-01-06] SVE kernels for CGEMM, ZGEMM, CTRMM, ZTRMM and corresponding SVE copy functions
   * [2022-01-18] SVE kernels and copy functions for TRSM
-
-* Ilya Kurdyukov <https://github.com/ilyakurdyukov>
-  * [2021-02-21] Add basic support for the Elbrus E2000 architecture
-
-* PLCT Lab, Institute of Software Chinese Academy of Sciences
-  * [2022-03] Support RISC-V Vector Intrinisc 1.0 version.
-  
-* Pablo Romero <https://github.com/pablorcum>
-  * [2022-08] Fix building from sources for QNX
-
-* Mark Seminatore <https://github.com/mseminatore>
-  * [2023-11-09] Improve Windows threading performance scaling
-  * [2024-02-09] Introduce MT_TRACE facility and improve code consistency
-
-* Dirreke <https://github.com/mseminatore>
-  * [2024-01-16] Add basic support for the CSKY architecture
-
-* Christopher Daley <https://github.com/cdaley>
-  * [2024-01-24] Optimize GEMV forwarding on ARM64 systems
-
-* Aniket P. Garade <https://github.com/garadeaniket>   Sushil Pratap Singh <https://github.com/SushilPratap04>  Juliya James <https://github.com/Juliya32> 
-  *  [2024-12-13] Optimized swap and rot  Level-1 BLAS routines with ARM SVE
-
-* Annop Wongwathanarat <annop.wongwathanarat@arm.com>
-  * [2025-01-10] Add thread throttling profile for SGEMM on NEOVERSEV1
-  * [2025-01-21] Optimize gemv_t_sve_v1x3 kernel
-  * [2025-02-26] Add sbgemv_t_bfdot kernel
-  * [2025-03-12] Fix aarch64 sbgemv_t compilation error for GCC < 13
-  * [2025-03-12] Optimize aarch64 sgemm_ncopy
-
-* Marek Michalowski <marek.michalowski@arm.com>
-  * [2025-01-21] Add thread throttling profile for SGEMV on `NEOVERSEV1`
-  * [2025-02-18] Add thread throttling profile for SGEMM on `NEOVERSEV2`
-  * [2025-02-19] Add thread throttling profile for SGEMV on `NEOVERSEV2`
-
-* Ye Tao <ye.tao@arm.com>
-  * [2025-02-03] Optimize SBGEMM kernel on NEOVERSEV1
-  * [2025-02-27] Add sbgemv_n_neon kernel
-  * [2025-05-17] Impl prototype of BGEMM inferface
-
-* Abhishek Kumar <https://github.com/abhishek-iitmadras>
-  * [2025-04-22] Optimise dot kernel for NEOVERSE V1
-  * [2025-07-23] ARM64-Enable bfloat16 kernels by default 
-
-* Sharif Inamdar <sharif.inamdar@arm.com>
-  * [2025-06-05] Optimize gemv_n_sve_v1x3 kernel
-
-* Guoyuan Li <https://github.com/guoyuanplct>
-  * [2025-04-11] Optimise gemv kernel for RISCV64_ZVL256B
-  * [2025-05-01] Optimise zgemv kernel for RISCV64_ZVL256B
-  * [2025-05-17] Optimise omatcopy/zomatcopy kernel for RISCV64_ZVL256B
-  * [2025-05-29] Optimise axpby kernel for RISCV64_ZVL256B
-  * [2025-06-05] Optimise hbmv kernel for RISCV64_ZVL256B
-
-* Anna Mayne <anna.mayne@arm.com>
-  * [2025-11-19] Update thread throttling profile for SGEMV on NEOVERSEV1 and NEOVERSEV2
-
-* Fadi Arafeh <fadi.arafeh@arm.com>
-  * [2026-03-05] Accelerate SVE128 SBGEMM/BGEMM
-
-* Nathan Sircombe <nathan.sircombe@arm.com>
-  * [2026-04-16] Add CPU ID for Neoverse V3
-hheei <hheei@users.noreply.github.com>
-
-* Aadityansha Verma <https://github.com/aadityansha06>
-  * [2026-07-14] Add independent transpose support for C in GEADD (sgeadd/dgeadd/cgeadd/zgeadd).
-
-* Vincent Lovero <https://github.com/vlovero>
-  * [2026-08-11] ARM v9.2 SME GEMM kernels for Apple M
-
-* Hugo Meiland <hugo@meiland.nl>
-  * [2026-08-09] Add Cortex-A72 DGEMM 6x8 microkernel and blocking

GotoBLAS_01Readme.txt

@@ -80,7 +80,7 @@
                       SUN
                       Fujitsu
 
-4. Supported precision
+4. Suported precision
 
  Now x86/x86_64 version support 80bit FP precision in addition to
 normal double presicion and single precision. Currently only

GotoBLAS_06WeirdPerformance.txt

@@ -11,7 +11,7 @@
    operation is finished.
 
 
-2. Similar problem may happen under virtual machine. If supervisor
+2. Simlar problem may happen under virtual machine. If supervisor
    allocates different cores for each scheduling, BLAS performnace
    will be bad. This is because BLAS also utilizes all cache,
    unexpected re-schedule for different core may result of heavy

Jenkinsfile

@@ -1,19 +1,9 @@
-pipeline {
-    agent { 
-        docker {
-            image 'osuosl/ubuntu-s390x'
+node {
+        stage('Checkout') {
+            checkout
         }
-    }
-    stages {
+
         stage('Build') {
-            steps {
-                sh 'make clean && make'
-            }
+            sh("make")
         }
-        stage('CMakeBuild') {
-            steps {
-                sh 'sudo apt update && sudo apt install cmake -y && make clean && rm -rf build && mkdir build && cd build && cmake -DDYNAMIC_ARCH=1 .. && make'
-            }
-        }
-    }
 }

Jenkinsfile.pwr

@@ -1,31 +0,0 @@
-pipeline {
-    agent none
-    stages {
-        stage('GCC build') {
-            agent {
-                docker {
-                    image 'osuosl/ubuntu-ppc64le:18.04' // gcc 7, gfortran 7
-                }
-            }
-            steps {
-                checkout scm
-                sh 'sudo apt update'
-                sh 'sudo apt install gfortran -y'
-                sh 'make clean && make'
-            }
-        }
-        stage('Clang build') {
-            agent {
-                docker {
-                    image 'osuosl/ubuntu-ppc64le:20.04' // clang 10, gfortran 9
-                }
-            }
-            steps {
-                checkout scm
-                sh 'sudo apt update'
-                sh 'sudo apt install -y clang gfortran'
-                sh 'make clean && make CC=clang'
-            }
-        }
-    }
-}

Makefile

@@ -1,10 +1,5 @@
 TOPDIR	= .
 include ./Makefile.system
-LNCMD = ln -fs
-OSNAME_DISPLAY ?= $(OSNAME)
-ifeq ($(FIXED_LIBNAME), 1)
-LNCMD = true
-endif
 
 BLASDIRS = interface driver/level2 driver/level3 driver/others
 
@@ -30,36 +25,25 @@ ifeq ($(NO_FORTRAN), 1)
 define NOFORTRAN
 1
 endef
-ifneq ($(NO_LAPACK), 1)
-define C_LAPACK
+define NO_LAPACK
 1
 endef
-endif
 export NOFORTRAN
 export NO_LAPACK
-export C_LAPACK
 endif
 
-ifeq ($(F_COMPILER),CRAY)
-LAPACK_NOOPT := $(filter-out -O0 -O1 -O2 -O3 -Ofast -Og -Os,$(LAPACK_FFLAGS))
-else
 LAPACK_NOOPT := $(filter-out -O0 -O1 -O2 -O3 -Ofast -O -Og -Os,$(LAPACK_FFLAGS))
-endif
-
-ifdef LAPACK_STRLEN
-LAPACK_FFLAGS += -DLAPACK_STRLEN=$(LAPACK_STRLEN)
-endif
 
 SUBDIRS_ALL = $(SUBDIRS) test ctest utest exports benchmark ../laswp ../bench cpp_thread_test
 
 .PHONY : all libs netlib $(RELA) test ctest shared install
-.NOTPARALLEL : shared
+.NOTPARALLEL : all libs $(RELA) prof lapack-test install blas-test
 
-all :: tests
+all :: libs netlib $(RELA) tests shared
 	@echo
 	@echo " OpenBLAS build complete. ($(LIB_COMPONENTS))"
 	@echo
-	@echo "  OS               ... $(OSNAME_DISPLAY)             "
+	@echo "  OS               ... $(OSNAME)             "
 	@echo "  Architecture     ... $(ARCH)               "
 ifndef BINARY64
 	@echo "  BINARY           ... 32bit                 "
@@ -94,11 +78,6 @@ ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
 	   echo "  Fortran compiler ... $(F_COMPILER)  (command line : $(FC))";\
 	fi
 endif
-
-ifeq ($(OSNAME), WINNT)
-	@-$(LNCMD) $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
-endif
-
 ifneq ($(OSNAME), AIX)
 	@echo -n "  Library Name     ... $(LIBNAME)"
 else
@@ -128,10 +107,6 @@ ifeq ($(OSNAME), Darwin)
 	@echo "\"make PREFIX=/your_installation_path/ install\"."
 	@echo
 	@echo "(or set PREFIX in Makefile.rule and run make install."
-	@echo
-	@echo "Note that any flags passed to make during build should also be passed to make install"
-	@echo "to circumvent any install errors."
-	@echo
 	@echo "If you want to move the .dylib to a new location later, make sure you change"
 	@echo "the internal name of the dylib with:"
 	@echo
@@ -140,25 +115,22 @@ endif
 	@echo
 	@echo "To install the library, you can run \"make PREFIX=/path/to/your/installation install\"."
 	@echo
-	@echo "Note that any flags passed to make during build should also be passed to make install"
-	@echo "to circumvent any install errors."
-	@echo
 
-shared : libs netlib $(RELA)
+shared :
 ifneq ($(NO_SHARED), 1)
 ifeq ($(OSNAME), $(filter $(OSNAME),Linux SunOS Android Haiku FreeBSD DragonFly))
 	@$(MAKE) -C exports so
-	@$(LNCMD) $(LIBSONAME) $(LIBPREFIX).so
-	@$(LNCMD) $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
+	@ln -fs $(LIBSONAME) $(LIBPREFIX).so
+	@ln -fs $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
 endif
 ifeq ($(OSNAME), $(filter $(OSNAME),OpenBSD NetBSD))
 	@$(MAKE) -C exports so
-	@$(LNCMD) $(LIBSONAME) $(LIBPREFIX).so
+	@ln -fs $(LIBSONAME) $(LIBPREFIX).so
 endif
 ifeq ($(OSNAME), Darwin)
 	@$(MAKE) -C exports dyn
-	@$(LNCMD) $(LIBDYNNAME) $(LIBPREFIX).dylib
-	@$(LNCMD) $(LIBDYNNAME) $(LIBPREFIX).$(MAJOR_VERSION).dylib
+	@ln -fs $(LIBDYNNAME) $(LIBPREFIX).dylib
+	@ln -fs $(LIBDYNNAME) $(LIBPREFIX).$(MAJOR_VERSION).dylib
 endif
 ifeq ($(OSNAME), WINNT)
 	@$(MAKE) -C exports dll
@@ -166,36 +138,29 @@ endif
 ifeq ($(OSNAME), CYGWIN_NT)
 	@$(MAKE) -C exports dll
 endif
-ifeq ($(OSNAME), AIX)
-	@$(MAKE) -C exports so
-endif
 endif
 
-tests : shared
+tests :
 ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
 	touch $(LIBNAME)
 ifndef NO_FBLAS
 	$(MAKE) -C test all
 endif
-endif
-ifneq ($(ONLY_CBLAS), 1)
 	$(MAKE) -C utest all
-endif
 ifneq ($(NO_CBLAS), 1)
-ifneq ($(ONLY_CBLAS), 1)
 	$(MAKE) -C ctest all
-endif
 ifeq ($(CPP_THREAD_SAFETY_TEST), 1)
 	$(MAKE) -C cpp_thread_test all
 endif
 endif
+endif
 
 libs :
 ifeq ($(CORE), UNKNOWN)
 	$(error OpenBLAS: Detecting CPU failed. Please set TARGET explicitly, e.g. make TARGET=your_cpu_target. Please read README for the detail.)
 endif
 ifeq ($(NOFORTRAN), 1)
-	$(info OpenBLAS: Detecting fortran compiler failed. Can only compile BLAS and f2c-converted LAPACK.)
+	$(info OpenBLAS: Detecting fortran compiler failed. Cannot compile LAPACK. Only compile BLAS.)
 endif
 ifeq ($(NO_STATIC), 1)
 ifeq ($(NO_SHARED), 1)
@@ -227,32 +192,16 @@ ifeq ($(DYNAMIC_OLDER), 1)
 	@echo DYNAMIC_OLDER=1 >> Makefile.conf_last
 endif	
 endif
-	@echo TARGET=$(CORE) >> Makefile.conf_last
 ifdef USE_THREAD
 	@echo USE_THREAD=$(USE_THREAD) >>  Makefile.conf_last
 endif
-ifdef SMP
-ifdef NUM_THREADS
-	@echo NUM_THREADS=$(NUM_THREADS) >>  Makefile.conf_last
-else
-	@echo NUM_THREADS=$(NUM_CORES) >>  Makefile.conf_last
-endif
-endif
-ifeq ($(USE_OPENMP),1)
-	@echo USE_OPENMP=1 >>  Makefile.conf_last
-endif
-ifeq ($(INTERFACE64),1)
-	@echo INTERFACE64=1 >>  Makefile.conf_last
-endif
-	@echo THELIBNAME=$(LIBNAME) >>  Makefile.conf_last
-	@echo THELIBSONAME=$(LIBSONAME) >>  Makefile.conf_last
-	@-$(LNCMD) $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
+	@-ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
 	@touch lib.grd
 
 prof : prof_blas prof_lapack
 
 prof_blas :
-	$(LNCMD) $(LIBNAME_P) $(LIBPREFIX)_p.$(LIBSUFFIX)
+	ln -fs $(LIBNAME_P) $(LIBPREFIX)_p.$(LIBSUFFIX)
 	for d in $(SUBDIRS) ; \
 	do if test -d $$d; then \
 	  $(MAKE) -C $$d prof || exit 1 ; \
@@ -263,7 +212,7 @@ ifeq ($(DYNAMIC_ARCH), 1)
 endif
 
 blas :
-	$(LNCMD) $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
+	ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
 	for d in $(BLASDIRS) ; \
 	do if test -d $$d; then \
 	  $(MAKE) -C $$d libs || exit 1 ; \
@@ -271,7 +220,7 @@ blas :
 	done
 
 hpl :
-	$(LNCMD) $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
+	ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
 	for d in $(BLASDIRS) ../laswp exports ; \
 	do if test -d $$d; then \
 	  $(MAKE) -C $$d $(@F) || exit 1 ; \
@@ -285,21 +234,26 @@ ifeq ($(DYNAMIC_ARCH), 1)
 endif
 
 hpl_p :
-	$(LNCMD) $(LIBNAME_P) $(LIBPREFIX)_p.$(LIBSUFFIX)
+	ln -fs $(LIBNAME_P) $(LIBPREFIX)_p.$(LIBSUFFIX)
 	for d in $(SUBDIRS) ../laswp exports ; \
 	do if test -d $$d; then \
 	  $(MAKE) -C $$d $(@F) || exit 1 ; \
 	fi; \
 	done
 
+ifeq ($(NO_LAPACK), 1)
+netlib :
+
+else
 netlib : lapack_prebuild
-ifneq ($(NO_LAPACK), 1)
+ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) lapacklib
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) tmglib
 endif
 ifneq ($(NO_LAPACKE), 1)
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) lapackelib
 endif
+endif
 
 ifeq ($(NO_LAPACK), 1)
 re_lapack :
@@ -313,25 +267,17 @@ prof_lapack : lapack_prebuild
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) lapack_prof
 
 lapack_prebuild :
-ifeq ($(NO_LAPACK), $(filter 0,$(NO_LAPACK)))
+ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
 	-@echo "FC          = $(FC)" > $(NETLIB_LAPACK_DIR)/make.inc
-ifeq ($(F_COMPILER), GFORTRAN)
-	-@echo "override FFLAGS      = $(LAPACK_FFLAGS) -fno-tree-vectorize" >> $(NETLIB_LAPACK_DIR)/make.inc
-else
 	-@echo "override FFLAGS      = $(LAPACK_FFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
-endif
 	-@echo "FFLAGS_DRV  = $(LAPACK_FFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "POPTS       = $(LAPACK_FPFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "FFLAGS_NOOPT       = -O0 $(LAPACK_NOOPT)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "PNOOPT      = $(LAPACK_FPFLAGS) -O0" >> $(NETLIB_LAPACK_DIR)/make.inc
 ifeq ($(C_COMPILER)$(F_COMPILER)$(USE_OPENMP), CLANGGFORTRAN1)
 	-@echo "LDFLAGS     = $(FFLAGS) $(EXTRALIB) -lomp" >> $(NETLIB_LAPACK_DIR)/make.inc
-else
-ifeq ($(C_COMPILER)$(F_COMPILER)$(USE_OPENMP), CLANGIBM1)
-	-@echo "LDFLAGS     = $(FFLAGS) $(EXTRALIB) -lomp" >> $(NETLIB_LAPACK_DIR)/make.inc
 else
 	-@echo "LDFLAGS     = $(FFLAGS) $(EXTRALIB)" >> $(NETLIB_LAPACK_DIR)/make.inc
-endif
 endif
 	-@echo "CC          = $(CC)" >> $(NETLIB_LAPACK_DIR)/make.inc
 	-@echo "override CFLAGS      = $(LAPACK_CFLAGS)" >> $(NETLIB_LAPACK_DIR)/make.inc
@@ -414,15 +360,14 @@ ifneq ($(CROSS), 1)
 	(cd $(NETLIB_LAPACK_DIR); ./lapack_testing.py -r -b TESTING)
 endif
 
-lapack-runtest: lapack-test
+lapack-runtest:
 	( cd $(NETLIB_LAPACK_DIR)/INSTALL; ./testlsame; ./testslamch; ./testdlamch; \
         ./testsecond; ./testdsecnd; ./testieee; ./testversion )
-	(cd $(NETLIB_LAPACK_DIR); ./lapack_testing.py -r -b TESTING )
+	(cd $(NETLIB_LAPACK_DIR); ./lapack_testing.py -r )
 
 
 blas-test:
 	(cd $(NETLIB_LAPACK_DIR)/BLAS/TESTING && rm -f x* *.out)
-
 	$(MAKE) -j 1 -C $(NETLIB_LAPACK_DIR) blas_testing
 	(cd $(NETLIB_LAPACK_DIR)/BLAS/TESTING && cat *.out)
 
@@ -432,9 +377,6 @@ dummy :
 install :
 	$(MAKE) -f Makefile.install install
 
-install_tests :
-	$(MAKE) -f Makefile.install install_tests
-
 clean ::
 	@for d in $(SUBDIRS_ALL) ; \
 	do if test -d $$d; then \
@@ -453,7 +395,7 @@ endif
 	@rm -f cblas.tmp cblas.tmp2
 	@touch $(NETLIB_LAPACK_DIR)/make.inc
 	@$(MAKE) -C $(NETLIB_LAPACK_DIR) clean
-	@rm -f $(NETLIB_LAPACK_DIR)/make.inc
+	@rm -f $(NETLIB_LAPACK_DIR)/make.inc $(NETLIB_LAPACK_DIR)/lapacke/include/lapacke_mangling.h
 	@$(MAKE) -C relapack clean
 	@rm -f *.grd Makefile.conf_last config_last.h
 	@(cd $(NETLIB_LAPACK_DIR)/TESTING && rm -f x* *.out testing_results.txt)

Makefile.alpha

@@ -1,24 +1,42 @@
+CPP	= $(CC) -E
+RANLIB  = ranlib
+
+ifeq ($(LIBSUBARCH), EV4)
+LIBNAME		= $(LIBPREFIX)_ev4.a
+LIBNAME_P	= $(LIBPREFIX)_ev4_p.a
+endif
+
+ifeq ($(LIBSUBARCH), EV5)
+LIBNAME		= $(LIBPREFIX)_ev5.a
+LIBNAME_P	= $(LIBPREFIX)_ev5_p.a
+endif
+
+ifeq ($(LIBSUBARCH), EV6)
+LIBNAME		= $(LIBPREFIX)_ev6.a
+LIBNAME_P	= $(LIBPREFIX)_ev6_p.a
+endif
+
 ifneq ($(COMPILER), NATIVE)
 # GCC User
-ifeq ($(CORE), EV4)
-CCOMMON_OPT += -mcpu=ev4
+ifeq ($(LIBSUBARCH), EV4)
+OPTION += -DEV4 -mcpu=ev4
 endif
-ifeq ($(CORE), EV5)
-CCOMMON_OPT += -mcpu=ev5
+ifeq ($(LIBSUBARCH), EV5)
+OPTION += -DEV5 -mcpu=ev5
 endif
-ifeq ($(CORE), EV6)
-CCOMMON_OPT += -mcpu=ev6
+ifeq ($(LIBSUBARCH), EV6)
+OPTION += -DEV6 -mcpu=ev6
 endif
 else
 # Compaq Compiler User
-ifeq ($(CORE), EV4)
-CCOMMON_OPT += -tune ev4 -arch ev4
+ifeq ($(LIBSUBARCH), EV4)
+OPTION += -DEV4 -tune ev4 -arch ev4
 endif
-ifeq ($(CORE), EV5)
-CCOMMON_OPT += -tune ev5 -arch ev5
+ifeq ($(LIBSUBARCH), EV5)
+OPTION += -DEV5 -tune ev5 -arch ev5
 endif
-ifeq ($(CORE), EV6)
-CCOMMON_OPT += -tune ev6 -arch ev6
+ifeq ($(LIBSUBARCH), EV6)
+OPTION += -DEV6 -tune ev6 -arch ev6
 endif
 endif
 

Makefile.arm64

@@ -1,40 +1,9 @@
-###############################################################################
-# Copyright (c) 2025, The OpenBLAS Project
-# All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. 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.
-# 3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-###############################################################################
-
 ifneq ($(C_COMPILER), PGI)
 
 ifeq ($(C_COMPILER), CLANG)
 ISCLANG=1
 endif
-ifeq ($(C_COMPILER), FUJITSU)
-ISCLANG=1
-endif
-ifeq "$(or $(GCCVERSIONGT4),$(ISCLANG))" ""
+ifneq (1, $(filter 1,$(GCCVERSIONGT4) $(ISCLANG)))
 CCOMMON_OPT += -march=armv8-a
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a
@@ -58,16 +27,6 @@ FCOMMON_OPT += -march=armv8-a+sve
 endif
 endif
 
-ifeq ($(CORE), ARMV9SME)
-CCOMMON_OPT += -march=armv9-a+sve2+sme+sme-f64f64
-FCOMMON_OPT += -march=armv9-a+sve2
-ifdef OS_WINDOWS
-ifeq ($(C_COMPILER), CLANG)
-CCOMMON_OPT += -mllvm --aarch64-stack-hazard-size=0
-endif
-endif
-endif
-
 ifeq ($(CORE), CORTEXA53)
 CCOMMON_OPT += -march=armv8-a -mtune=cortex-a53
 ifneq ($(F_COMPILER), NAG)
@@ -96,25 +55,11 @@ FCOMMON_OPT += -march=armv8-a -mtune=cortex-a73
 endif
 endif
 
-ifeq ($(CORE), CORTEXA76)
-CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a76
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a76
-endif
-endif
-
-ifeq ($(CORE), FT2000)
-CCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
-endif
-endif
-
 # Use a72 tunings because Neoverse-N1 is only available
 # in GCC>=9
 ifeq ($(CORE), NEOVERSEN1)
 ifeq (1, $(filter 1,$(GCCVERSIONGTEQ7) $(ISCLANG)))
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ9) $(ISCLANG)))
+ifeq ($(GCCVERSIONGTEQ9), 1)
 CCOMMON_OPT += -march=armv8.2-a -mtune=neoverse-n1
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8.2-a -mtune=neoverse-n1
@@ -134,40 +79,29 @@ endif
 endif
 
 # Use a72 tunings because Neoverse-V1 is only available
-# in GCC>=10.4
+# in GCC>=9.4
 ifeq ($(CORE), NEOVERSEV1)
 ifeq (1, $(filter 1,$(GCCVERSIONGTEQ7) $(ISCLANG)))
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ10) $(ISCLANG)))
-ifeq (1, $(filter 1,$(GCCMINORVERSIONGTEQ4) $(GCCVERSIONGTEQ11) $(ISCLANG)))
-CCOMMON_OPT += -march=armv8.4-a+sve+bf16
-ifeq (1, $(ISCLANG))
-CCOMMON_OPT += -mtune=cortex-x1
-else
-CCOMMON_OPT += -mtune=neoverse-v1
-endif
+ifeq ($(GCCVERSIONGTEQ9), 1)
+ifeq (1, $(filter 1,$(GCCMINORVERSIONGTEQ4) $(GCCVERSIONGTEQ10)))
+CCOMMON_OPT += -march=armv8.4-a -mtune=neoverse-v1
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8.4-a -mtune=neoverse-v1
 endif
 else
-CCOMMON_OPT += -march=armv8.4-a+sve+bf16 
-ifneq ($(CROSS), 1)
-CCOMMON_OPT += -mtune=native
-endif
+CCOMMON_OPT += -march=armv8.4-a -mtune=native
 ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.4-a 
-ifneq ($(CROSS), 1)
-FCOMMON_OPT += -mtune=native
-endif
+FCOMMON_OPT += -march=armv8.4-a -mtune=native
 endif
 endif
 else
-CCOMMON_OPT += -march=armv8.2-a+sve -mtune=cortex-a72
+CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
 endif
 endif
 else
-CCOMMON_OPT += -march=armv8-a+sve -mtune=cortex-a72
+CCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
 endif
@@ -175,74 +109,39 @@ endif
 endif
 
 # Use a72 tunings because Neoverse-N2 is only available
-# in GCC>=10.4
+# in GCC>=9.4
 ifeq ($(CORE), NEOVERSEN2)
 ifeq (1, $(filter 1,$(GCCVERSIONGTEQ7) $(ISCLANG)))
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ10) $(ISCLANG)))
-ifeq (1, $(filter 1,$(GCCMINORVERSIONGTEQ4) $(GCCVERSIONGTEQ11) $(ISCLANG)))
-ifneq ($(OSNAME), Darwin)
-CCOMMON_OPT += -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-n2
-else
-CCOMMON_OPT += -march=armv8.2-a+sve+bf16 -mtune=cortex-a72
-endif
+ifeq ($(GCCVERSIONGTEQ9), 1)
+ifeq (1, $(filter 1,$(GCCMINORVERSIONGTEQ4) $(GCCVERSIONGTEQ10)))
+CCOMMON_OPT += -march=armv8.5-a -mtune=neoverse-n2
 ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-n2
+FCOMMON_OPT += -march=armv8.5-a -mtune=neoverse-n2
 endif
 else
-CCOMMON_OPT += -march=armv8.5-a+sve+bf16
-ifneq ($(CROSS), 1)
-CCOMMON_OPT += -mtune=native
-endif
+CCOMMON_OPT += -march=armv8.5-a -mtune=native
 ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.5-a 
-ifneq ($(CROSS), 1)
-FCOMMON_OPT += -mtune=native
-endif
+FCOMMON_OPT += -march=armv8.5-a -mtune=native
 endif
 endif
 else
-CCOMMON_OPT += -march=armv8.2-a+sve+bf16 -mtune=cortex-a72
+CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
 endif
 endif
 else
-CCOMMON_OPT += -march=armv8-a+sve+bf16 -mtune=cortex-a72
+CCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a -mtune=cortex-a72
 endif
 endif
 endif
 
-# Detect ARM Neoverse V2.
-ifeq ($(CORE), NEOVERSEV2)
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ13) $(ISCLANG)))
-CCOMMON_OPT += -mcpu=neoverse-v2
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -mcpu=neoverse-v2
-endif
-else
-CCOMMON_OPT += -march=armv8.2-a+sve+bf16 -mtune=neoverse-n1
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=neoverse-n1
-endif
-endif
-endif
-
-# Detect Ampere AmpereOne(ampere1,ampere1a) processors.
-ifeq ($(CORE), AMPERE1)
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ12) $(ISCLANG)))
-CCOMMON_OPT += -march=armv8.6-a+crypto+crc+fp16+sha3+rng
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.6-a+crypto+crc+fp16+sha3+rng
-endif
-endif
-endif
-
 # Use a53 tunings because a55 is only available in GCC>=8.1
 ifeq ($(CORE), CORTEXA55)
 ifeq (1, $(filter 1,$(GCCVERSIONGTEQ7) $(ISCLANG)))
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ8) $(ISCLANG)))
+ifeq ($(GCCVERSIONGTEQ8), 1)
 CCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a55
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a55
@@ -283,13 +182,8 @@ endif
 endif
 
 ifeq ($(CORE), THUNDERX3T110)
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ10) $(ISCLANG)))
-CCOMMON_OPT += -march=armv8.3-a 
-ifeq (0, $(ISCLANG))
-CCOMMON_OPT += -mtune=thunderx3t110
-else
-CCOMMON_OPT += -mtune=thunderx2t99
-endif
+ifeq ($(GCCVERSIONGTEQ10), 1)
+CCOMMON_OPT += -march=armv8.3-a -mtune=thunderx3t110
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8.3-a -mtune=thunderx3t110
 endif
@@ -308,18 +202,6 @@ FCOMMON_OPT += -march=armv8.3-a
 endif
 endif
 
-ifeq ($(CORE), VORTEXM4)
-ifneq ($(C_COMPILER), GCC)
-CCOMMON_OPT += -march=armv8.4-a+sme+sme-f64f64
-#ifneq ($(APPLECLANG),1)
-#override LDFLAGS += -lclang_rt_builtins-aarch64
-#endif
-else
-CCOMMON_OPT += -march=armv8.4-a
-endif
-FCOMMON_OPT += -march=armv8.4-a
-endif
-
 ifeq (1, $(filter 1,$(GCCVERSIONGTEQ9) $(ISCLANG)))
 ifeq ($(CORE), TSV110)
 CCOMMON_OPT += -march=armv8.2-a -mtune=tsv110
@@ -329,118 +211,24 @@ endif
 endif
 endif
 
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ9) $(ISCLANG)))
+ifeq ($(GCCVERSIONGTEQ9), 1)
 ifeq ($(CORE), EMAG8180)
-CCOMMON_OPT += -march=armv8-a
-ifeq  ($(ISCLANG), 0)
-CCOMMON_OPT += -mtune=emag
-endif
+CCOMMON_OPT += -march=armv8-a -mtune=emag
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8-a -mtune=emag
 endif
 endif
 endif
 
+ifeq (1, $(filter 1,$(GCCVERSIONGTEQ11) $(ISCLANG)))
 ifeq ($(CORE), A64FX)
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ10) $(ISCLANG)))
-ifeq (1, $(filter 1,$(GCCMINORVERSIONGTEQ3) $(GCCVERSIONGTEQ11) $(ISCLANG)))
 CCOMMON_OPT += -march=armv8.2-a+sve -mtune=a64fx
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=armv8.2-a+sve -mtune=a64fx
 endif
-else
-CCOMMON_OPT += -march=armv8.4-a+sve -mtune=neoverse-n1
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.4-a -mtune=neoverse-n1
-endif
-endif
-endif
-endif
-
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ11) $(ISCLANG)))
-ifeq ($(CORE), CORTEXX1)
-CCOMMON_OPT += -march=armv8.2-a
-ifeq (1, $(filter 1,$(GCCMINORVERSIONGTEQ4) $(GCCVERSIONGTEQ12) $(ISCLANG)))
-CCOMMON_OPT += -mtune=cortex-x1
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-x1
-endif
-else
-CCOMMON_OPT += -mtune=cortex-a72
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.2-a -mtune=cortex-a72
-endif
-endif
-endif
-endif
-
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ11) $(ISCLANG)))
-ifeq ($(CORE), CORTEXX2)
-CCOMMON_OPT += -march=armv8.4-a+sve
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.4-a+sve
-endif
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ12) $(ISCLANG)))
-CCOMMON_OPT += -mtune=cortex-x2
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -mtune=cortex-x2
-endif
-endif
-endif
-endif
-
-#ifeq (1, $(filter 1,$(ISCLANG)))
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ11) $(ISCLANG)))
-ifeq ($(CORE), CORTEXA510)
-CCOMMON_OPT += -march=armv8.4-a+sve
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.4-a+sve
-endif
-endif
-endif
-
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ11) $(ISCLANG)))
-ifeq ($(CORE), CORTEXA710)
-CCOMMON_OPT += -march=armv8.4-a+sve
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -march=armv8.4-a+sve
-endif
-ifeq (1, $(filter 1,$(GCCVERSIONGTEQ12) $(ISCLANG)))
-CCOMMON_OPT += -mtune=cortex-a710
-ifneq ($(F_COMPILER), NAG)
-FCOMMON_OPT += -mtune=cortex-a710
-endif
-endif
 endif
 endif
 
 endif
 
-else
-# NVIDIA HPC options necessary to enable SVE in the compiler
-ifeq ($(CORE), THUNDERX2T99)
-CCOMMON_OPT += -tp=thunderx2t99
-FCOMMON_OPT += -tp=thunderx2t99
-endif
-ifeq ($(CORE), NEOVERSEN1)
-CCOMMON_OPT += -tp=neoverse-n1
-FCOMMON_OPT += -tp=neoverse-n1
-endif
-ifeq ($(CORE), NEOVERSEV1)
-CCOMMON_OPT += -tp=neoverse-v1
-FCOMMON_OPT += -tp=neoverse-v1
-endif
-ifeq ($(CORE), NEOVERSEV2)
-CCOMMON_OPT += -tp=neoverse-v2
-FCOMMON_OPT += -tp=neoverse-v2
-endif
-ifeq ($(CORE), ARMV8SVE)
-CCOMMON_OPT += -tp=neoverse-v2
-FCOMMON_OPT += -tp=neoverse-v2
-endif
-ifeq ($(CORE), ARMV9SVE)
-CCOMMON_OPT += -tp=neoverse-v2
-FCOMMON_OPT += -tp=neoverse-v2
-endif
-
 endif

Makefile.csky

@@ -1,4 +0,0 @@
-ifeq ($(CORE), CK860FV)
-CCOMMON_OPT += -march=ck860v -mcpu=ck860fv -mfdivdu -mhard-float
-FCOMMON_OPT += -march=ck860v -mcpu=ck860fv -mfdivdu -mhard-float -static
-endif

Makefile.e2k

@@ -1 +0,0 @@
-COPT	= -Wall -O2 # -DGEMMTEST

Makefile.install

@@ -2,21 +2,6 @@ TOPDIR	= .
 export GOTOBLAS_MAKEFILE = 1
 -include $(TOPDIR)/Makefile.conf_last
 include ./Makefile.system
-LNCMD = ln -fs
-
-ifdef THELIBNAME
-LIBNAME=$(THELIBNAME)
-LIBSONAME=$(THELIBSONAME)
-endif
-ifeq ($(FIXED_LIBNAME), 1)
-LNCMD = true
-endif
-ifeq ($(INTERFACE64),1)
-USE_64BITINT=1
-endif
-ifeq ($(USE_OPENMP),1)
-	FOMP_OPT:= -fopenmp
-endif
 
 PREFIX ?= /opt/OpenBLAS
 
@@ -29,11 +14,6 @@ OPENBLAS_CMAKE_CONFIG := OpenBLASConfig.cmake
 OPENBLAS_CMAKE_CONFIG_VERSION := OpenBLASConfigVersion.cmake
 OPENBLAS_PKGCONFIG_DIR := $(OPENBLAS_LIBRARY_DIR)/pkgconfig
 PKG_EXTRALIB := $(EXTRALIB)
-ifeq ($(INTERFACE64),1)
-	SUFFIX64=64
-endif
-PKGFILE := $(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE)$(SUFFIX64).pc
-
 ifeq ($(USE_OPENMP), 1)
   ifeq ($(C_COMPILER), PGI)
           PKG_EXTRALIB += -lomp
@@ -71,61 +51,31 @@ install : 	lib.grd
 	@cat common_interface.h >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/f77blas.h"
 	@echo \#endif >> "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/f77blas.h"
 
-ifneq ($(NO_CBLAS),1)
+ifndef NO_CBLAS
 	@echo Generating cblas.h in $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-	@sed -e 's/openblas_dojob_callback/OPENBLAS_DOJOB_CALLBACK_TYPE/g' \
-	     -e 's/openblas_threads_callback/OPENBLAS_THREADS_CALLBACK_TYPE/g' \
-	     -e 's/openblas_xerbla_handler/OPENBLAS_XERBLA_HANDLER_TYPE/g' \
-	     cblas.h > cblas.tmp
+	@cp cblas.h cblas.tmp
 ifdef SYMBOLPREFIX
-	@sed 's/cblas[^() ]*/$(SYMBOLPREFIX)&/g' cblas.tmp > cblas.tmp2
-	@sed 's/openblas[^() ]*/$(SYMBOLPREFIX)&/g'  cblas.tmp2 > cblas.tmp
+	@sed 's/cblas[^( ]*/$(SYMBOLPREFIX)&/g' cblas.tmp > cblas.tmp2
+	@sed 's/openblas[^( ]*/$(SYMBOLPREFIX)&/g'  cblas.tmp2 > cblas.tmp
 	#change back any openblas_complex_float and double that got hit
 	@sed 's/$(SYMBOLPREFIX)openblas_complex_/openblas_complex_/g'  cblas.tmp > cblas.tmp2
-	@sed 's/goto[^() ]*/$(SYMBOLPREFIX)&/g'  cblas.tmp2 > cblas.tmp
+	@sed 's/goto[^( ]*/$(SYMBOLPREFIX)&/g'  cblas.tmp2 > cblas.tmp
 endif
 ifdef SYMBOLSUFFIX
-	@sed 's/cblas[^() ]*/&$(SYMBOLSUFFIX)/g' cblas.tmp > cblas.tmp2
-	@sed 's/openblas[^() ]*/&$(SYMBOLSUFFIX)/g'  cblas.tmp2 > cblas.tmp
+	@sed 's/cblas[^( ]*/&$(SYMBOLSUFFIX)/g' cblas.tmp > cblas.tmp2
+	@sed 's/openblas[^( ]*/&$(SYMBOLSUFFIX)/g'  cblas.tmp2 > cblas.tmp
 	#change back any openblas_complex_float and double that got hit
 	@sed 's/\(openblas_complex_\)\([^ ]*\)$(SYMBOLSUFFIX)/\1\2 /g'  cblas.tmp > cblas.tmp2
-	@sed 's/goto[^() ]*/&$(SYMBOLSUFFIX)/g'  cblas.tmp2 > cblas.tmp
+	@sed 's/goto[^( ]*/&$(SYMBOLSUFFIX)/g'  cblas.tmp2 > cblas.tmp
 endif
-
-	@sed 's/OPENBLAS_EXPORT //'  cblas.tmp > cblas.tmp2
-	@sed 's/common/openblas_config/g' cblas.tmp2 > cblas.tmp
-
-	@sed -e 's/OPENBLAS_DOJOB_CALLBACK_TYPE/openblas_dojob_callback/g' \
-	     -e 's/OPENBLAS_THREADS_CALLBACK_TYPE/openblas_threads_callback/g' \
-	     -e 's/OPENBLAS_XERBLA_HANDLER_TYPE/openblas_xerbla_handler/g' \
-	     -e 's/common/openblas_config/g' \
-	     cblas.tmp > "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/cblas.h"
-
+	@sed 's/common/openblas_config/g' cblas.tmp > "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/cblas.h"
 endif
 
 ifneq ($(OSNAME), AIX)
-ifneq ($(NO_LAPACKE), 1)
-	@cp $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke.h lapacke_h.tmp
-ifdef SYMBOLPREFIX
-	@sed 's/LAPACKE_[a-z1-9].[^() ]*/$(SYMBOLPREFIX)&/g' lapacke_h.tmp > lapacke.tmp2
-	@mv lapacke.tmp2 lapacke_h.tmp
-endif
-ifdef SYMBOLSUFFIX
-	@sed 's/LAPACKE_[a-z1-9].[^() ]*/&$(SYMBOLSUFFIX)/g' lapacke_h.tmp > lapacke.tmp2
-	@mv lapacke.tmp2 lapacke_h.tmp
-endif
-	@-install -m644 lapacke_h.tmp "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke.h"
+ifndef NO_LAPACKE
 	@echo Copying LAPACKE header files to $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
-	@cp $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapack.h lapack_h.tmp
-ifdef SYMBOLPREFIX
-	@sed 's/LAPACK_[a-z1-9]*(\.\.\.)/$(SYMBOLPREFIX)&/g' lapack_h.tmp > lapack.tmp2
-	@mv lapack.tmp2 lapack_h.tmp
-endif
-ifdef SYMBOLSUFFIX
-	@sed 's/\(#define $(SYMBOLPREFIX)LAPACK_[a-z1-9].*\)\((...)\)/\1$(SYMBOLSUFFIX)\2/g' lapack_h.tmp > lapack.tmp2
-	@mv lapack.tmp2 lapack_h.tmp
-endif
-	@-install -m644 lapack_h.tmp "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapack.h"
+	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapack.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapack.h"
+	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke.h"
 	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_config.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_config.h"
 	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_mangling_with_flags.h.in "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_mangling.h"
 	@-install -m644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke_utils.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke_utils.h"
@@ -136,7 +86,7 @@ ifneq ($(NO_STATIC),1)
 	@echo Copying the static library to $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
 	@install -m644 $(LIBNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
-	$(LNCMD) $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
+	ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
 endif
 #for install shared library
 ifneq ($(NO_SHARED),1)
@@ -144,21 +94,21 @@ ifneq ($(NO_SHARED),1)
 ifeq ($(OSNAME), $(filter $(OSNAME),Linux SunOS Android Haiku FreeBSD DragonFly))
 	@install -m755 $(LIBSONAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
-	$(LNCMD) $(LIBSONAME) $(LIBPREFIX).so ; \
-	$(LNCMD) $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
+	ln -fs $(LIBSONAME) $(LIBPREFIX).so ; \
+	ln -fs $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
 endif
 
 ifeq ($(OSNAME), $(filter $(OSNAME),OpenBSD NetBSD))
 	@cp $(LIBSONAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
-	$(LNCMD) $(LIBSONAME) $(LIBPREFIX).so
+	ln -fs $(LIBSONAME) $(LIBPREFIX).so
 endif
 ifeq ($(OSNAME), Darwin)
 	@-cp $(LIBDYNNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
 	@-install_name_tool -id "$(OPENBLAS_LIBRARY_DIR)/$(LIBPREFIX).$(MAJOR_VERSION).dylib" "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)/$(LIBDYNNAME)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
-	$(LNCMD) $(LIBDYNNAME) $(LIBPREFIX).dylib ; \
-	$(LNCMD) $(LIBDYNNAME) $(LIBPREFIX).$(MAJOR_VERSION).dylib
+	ln -fs $(LIBDYNNAME) $(LIBPREFIX).dylib ; \
+	ln -fs $(LIBDYNNAME) $(LIBPREFIX).$(MAJOR_VERSION).dylib
 endif
 ifeq ($(OSNAME), WINNT)
 	@-cp $(LIBDLLNAME) "$(DESTDIR)$(OPENBLAS_BINARY_DIR)"
@@ -172,7 +122,7 @@ endif
 
 else
 #install on AIX has different options syntax
-ifneq ($(NO_LAPACKE), 1)
+ifndef NO_LAPACKE
 	@echo Copying LAPACKE header files to $(DESTDIR)$(OPENBLAS_INCLUDE_DIR)
 	@-installbsd -c -m 644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapack.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapack.h"
 	@-installbsd -c -m 644 $(NETLIB_LAPACK_DIR)/LAPACKE/include/lapacke.h "$(DESTDIR)$(OPENBLAS_INCLUDE_DIR)/lapacke.h"
@@ -186,86 +136,49 @@ ifneq ($(NO_STATIC),1)
 	@echo Copying the static library to $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
 	@installbsd -c -m 644 $(LIBNAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
-	$(LNCMD) $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
+	ln -fs $(LIBNAME) $(LIBPREFIX).$(LIBSUFFIX)
 endif
 #for install shared library
 ifneq ($(NO_SHARED),1)
 	@echo Copying the shared library to $(DESTDIR)$(OPENBLAS_LIBRARY_DIR)
 	@installbsd -c -m 755 $(LIBSONAME) "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)"
 	@cd "$(DESTDIR)$(OPENBLAS_LIBRARY_DIR)" ; \
-	$(LNCMD) $(LIBSONAME) $(LIBPREFIX).so ; \
-	$(LNCMD) $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
+	ln -fs $(LIBSONAME) $(LIBPREFIX).so ; \
+	ln -fs $(LIBSONAME) $(LIBPREFIX).so.$(MAJOR_VERSION)
 endif
 
 endif
 
 #Generating openblas.pc
-ifeq ($(INTERFACE64),1)
-	SUFFIX64=64
-endif
-	@echo Generating $(LIBSONAMEBASE)$(SUFFIX64).pc in "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)"
-	@echo 'libdir='$(OPENBLAS_LIBRARY_DIR) > "$(PKGFILE)"
-	@echo 'libprefix='$(LIBNAMEPREFIX) >> "$(PKGFILE)"
-	@echo 'libnamesuffix='$(LIBNAMESUFFIX) >> "$(PKGFILE)"
-	@echo 'libsuffix='$(SYMBOLSUFFIX) >> "$(PKGFILE)"
-	@echo 'includedir='$(OPENBLAS_INCLUDE_DIR) >> "$(PKGFILE)"
-	@echo 'omp_opt='$(FOMP_OPT) >> "$(PKGFILE)"
-	@echo 'openblas_config= USE_64BITINT='$(INTERFACE64) 'DYNAMIC_ARCH='$(DYNAMIC_ARCH) 'DYNAMIC_OLDER='$(DYNAMIC_OLDER) 'NO_CBLAS='$(NO_CBLAS) 'NO_LAPACK='$(NO_LAPACK) 'NO_LAPACKE='$(NO_LAPACKE) 'NO_AFFINITY='$(NO_AFFINITY) 'USE_OPENMP='$(USE_OPENMP) $(TARGET) 'MAX_THREADS='$(NUM_THREADS)>> "$(PKGFILE)"
-	@echo 'version='$(VERSION) >> "$(PKGFILE)"
-	@echo 'extralib='$(PKG_EXTRALIB) >> "$(PKGFILE)"
-	@cat openblas.pc.in >> "$(PKGFILE)"
+	@echo Generating $(LIBSONAMEBASE).pc in "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)"
+	@echo 'libdir='$(OPENBLAS_LIBRARY_DIR) > "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
+	@echo 'includedir='$(OPENBLAS_INCLUDE_DIR) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
+	@echo 'openblas_config= USE_64BITINT='$(USE_64BITINT) 'DYNAMIC_ARCH='$(DYNAMIC_ARCH) 'DYNAMIC_OLDER='$(DYNAMIC_OLDER) 'NO_CBLAS='$(NO_CBLAS) 'NO_LAPACK='$(NO_LAPACK) 'NO_LAPACKE='$(NO_LAPACKE) 'NO_AFFINITY='$(NO_AFFINITY) 'USE_OPENMP='$(USE_OPENMP) $(CORE) 'MAX_THREADS='$(NUM_THREADS)>> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
+	@echo 'version='$(VERSION) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
+	@echo 'extralib='$(PKG_EXTRALIB) >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
+	@cat openblas.pc.in >> "$(DESTDIR)$(OPENBLAS_PKGCONFIG_DIR)/$(LIBSONAMEBASE).pc"
 
 
 #Generating OpenBLASConfig.cmake
-ifneq ($(origin _OpenBLAS_ROOT_DIR),"undefined")
-
 	@echo Generating $(OPENBLAS_CMAKE_CONFIG) in $(DESTDIR)$(OPENBLAS_CMAKE_DIR)
 	@echo "SET(OpenBLAS_VERSION \"${VERSION}\")" > "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-	@echo "file(REAL_PATH \"../../..\" _OpenBLAS_ROOT_DIR BASE_DIRECTORY \$${CMAKE_CURRENT_LIST_DIR} )" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-	@echo "SET(OpenBLAS_INCLUDE_DIRS \$${_OpenBLAS_ROOT_DIR}/include)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
+	@echo "SET(OpenBLAS_INCLUDE_DIRS ${OPENBLAS_INCLUDE_DIR})" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
 
 ifneq ($(NO_SHARED),1)
 #ifeq logical or
 ifeq ($(OSNAME), $(filter $(OSNAME),Linux FreeBSD NetBSD OpenBSD DragonFly))
-	@echo "SET(OpenBLAS_LIBRARIES \$${_OpenBLAS_ROOT_DIR}/lib/$(LIBPREFIX).so)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
+	@echo "SET(OpenBLAS_LIBRARIES ${OPENBLAS_LIBRARY_DIR}/$(LIBPREFIX).so)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
 endif
-ifeq ($(OSNAME), $(filter $(OSNAME),WINNT CYGWIN_NT))
-	@echo "SET(OpenBLAS_LIBRARIES \$${_OpenBLAS_ROOT_DIR}/bin/$(LIBDLLNAME))" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-endif
-ifeq ($(OSNAME), Darwin)
-	@echo "SET(OpenBLAS_LIBRARIES \$${_OpenBLAS_ROOT_DIR}/lib/$(LIBPREFIX).dylib)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-endif
-	@echo "add_library(OpenBLAS::OpenBLAS SHARED IMPORTED)"
-	@echo "target_include_directories(OpenBLAS::OpenBLAS INTERFACE \$${OpenBLAS_INCLUDE_DIRS})"
-ifeq ($(OSNAME), $(filter $(OSNAME),WINNT CYGWIN_NT))
-	@echo "set_property(TARGET OpenBLAS::OpenBLAS PROPERTY IMPORTED_LOCATION \$${OpenBLAS_LIBRARIES})"
-	@echo "set_property(TARGET OpenBLAS::OpenBLAS PROPERTY IMPORTED_IMPLIB \$${_OpenBLAS_ROOT_DIR}/lib/libopenblas.lib)"
-endif
-else
-#only static
-	@echo "SET(OpenBLAS_LIBRARIES \$${_OpenBLAS_ROOT_DIR}/lib/$(LIBPREFIX).$(LIBSUFFIX))" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-endif
-else
-	echo Generating $(OPENBLAS_CMAKE_CONFIG) in $(DESTDIR)$(OPENBLAS_CMAKE_DIR)
-	@echo "SET(OpenBLAS_VERSION \"${VERSION}\")" > "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-	@echo "SET(OpenBLAS_INCLUDE_DIRS ${OPENBLAS_INCLUDE_DIR})" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-ifneq ($(NO_SHARED),1)
-#ifeq logical or
-ifeq ($(OSNAME), $(filter $(OSNAME),Linux FreeBSD NetBSD OpenBSD DragonFly))
-	@echo "SET(OpenBLAS_LIBRARIES ${OPENBLAS_LIBRARY_DIR}/$(LIBPREFIX)$(SYMBOLSUFFIX).so)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-	endif
 ifeq ($(OSNAME), $(filter $(OSNAME),WINNT CYGWIN_NT))
 	@echo "SET(OpenBLAS_LIBRARIES ${OPENBLAS_BINARY_DIR}/$(LIBDLLNAME))" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
-	ifeq ($(OSNAME), Darwin)
+endif
+ifeq ($(OSNAME), Darwin)
 	@echo "SET(OpenBLAS_LIBRARIES ${OPENBLAS_LIBRARY_DIR}/$(LIBPREFIX).dylib)" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
 endif
 else
 #only static
 	@echo "SET(OpenBLAS_LIBRARIES ${OPENBLAS_LIBRARY_DIR}/$(LIBPREFIX).$(LIBSUFFIX))" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG)"
 endif
-endif
-endif
-
 #Generating OpenBLASConfigVersion.cmake
 	@echo Generating $(OPENBLAS_CMAKE_CONFIG_VERSION) in $(DESTDIR)$(OPENBLAS_CMAKE_DIR)
 	@echo "set (PACKAGE_VERSION \"${VERSION}\")" > "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
@@ -278,96 +191,3 @@ endif
 	@echo "  endif ()" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
 	@echo "endif ()" >> "$(DESTDIR)$(OPENBLAS_CMAKE_DIR)/$(OPENBLAS_CMAKE_CONFIG_VERSION)"
 	@echo Install OK!
-
-install_tests : lib.grd
-ifneq ($(ONLY_CBLAS), 1)
-	@install -m 666 utest/openblas_utest$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 utest/openblas_utest_ext$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
-ifndef NO_FBLAS
-ifeq ($(BUILD_BFLOAT16),1)
-	@install -m 666 test/test_sbgemm$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-ifeq ($(BUILD_SINGLE),1)
-	@install -m 666 test/sblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/sblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/sblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/sblat2.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/sblat3.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-ifeq ($(BUILD_DOUBLE),1)
-	@install -m 666 test/dblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/dblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/dblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/dblat2.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/dblat3.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-ifeq ($(BUILD_COMPLEX),1)
-	@install -m 666 test/cblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/cblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/cblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/cblat2.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/cblat3.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-ifeq ($(ARCH), filter($(ARCH), x86 x86_64 ia64 MIPS))
-	@install -m 666 test/cblat3_3m$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/cblat3_3m.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-endif
-ifeq ($(BUILD_COMPLEX16),1)
-	@install -m 666 test/zblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/zblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/zblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/zblat2.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/zblat3.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-ifeq ($(ARCH), filter($(ARCH), x86 x86_64 ia64 MIPS))
-	@install -m 666 test/zblat3_3m$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 test/zblat3_3m.dat $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-endif
-endif
-endif
-ifneq ($(ONLY_CBLAS), 1)
-ifeq ($(BUILD_SINGLE),1)
-	@install -m 666 ctest/xscblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xscblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xscblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/sin2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/sin3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-ifeq ($(BUILD_DOUBLE),1)
-	@install -m 666 ctest/xdcblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xdcblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xdcblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/din2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/din3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-ifeq ($(BUILD_COMPLEX),1)
-	@install -m 666 ctest/xccblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xccblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xccblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/cin2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/cin3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-ifeq ($(ARCH), filter($(ARCH), x86 x86_64 ia64 MIPS))
-	@install -m 666 ctest/xccblat3_3m$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/cin3_3m $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-endif
-ifeq ($(BUILD_COMPLEX16),1)
-	@install -m 666 ctest/xzcblat1$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xzcblat2$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/xzcblat3$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/zin2 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/zin3 $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-ifeq ($(ARCH), filter($(ARCH), x86 x86_64 ia64 MIPS))
-	@install -m 666 ctest/xzcblat3_3m$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 ctest/zin3_3m $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-endif
-
-endif
-ifeq ($(CPP_THREAD_SAFETY_TEST), 1)
-	@install -m 666 cpp_thread_test/dgemm_tester$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 cpp_thread_test/dgemm_mixed_tester$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-	@install -m 666 cpp_thread_test/dgemv_tester$(EXE) $(DESTDIR)$(OPENBLAS_BINARY_DIR)
-endif
-endif

Makefile.mips

@@ -1,4 +1,3 @@
-MSA_FLAGS = -mmsa -mfp64 -mload-store-pairs
 ifdef BINARY64
 else
 endif

Makefile.mips64

@@ -1,4 +1,3 @@
-MSA_FLAGS = -mmsa -mfp64 -mload-store-pairs
 ifdef BINARY64
 else
 endif

Makefile.power

@@ -11,30 +11,18 @@ endif
 
 ifeq ($(CORE), POWER10)
 ifneq ($(C_COMPILER), PGI)
-ifeq ($(C_COMPILER), GCC)
-ifeq ($(GCCVERSIONGTEQ10), 1)
-CCOMMON_OPT += -O3 -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math
-else ifneq ($(GCCVERSIONGT4), 1)
-$(warning your compiler is too old to fully support POWER9, getting a newer version of gcc is recommended)
-CCOMMON_OPT += -O3 -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math
-else
-$(warning your compiler is too old to fully support POWER10, getting a newer version of gcc is recommended)
-CCOMMON_OPT += -O3 -mcpu=power9 -mtune=power9 -mvsx -fno-fast-math
-endif
-else
-CCOMMON_OPT += -O3 -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math
-endif
+CCOMMON_OPT += -Ofast -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math
 ifeq ($(F_COMPILER), IBM)
-FCOMMON_OPT += -O2 -qrecur -qnosave -qarch=pwr10 -qtune=pwr10 -qfloat=nomaf -qzerosize
+FCOMMON_OPT += -O2 -qrecur -qnosave
 else
-FCOMMON_OPT += -O2 -frecursive -mcpu=power10 -mtune=power10 -fno-fast-math
+FCOMMON_OPT += -O2 -frecursive -mcpu=power10 -mtune=power10  -fno-fast-math
 endif
 endif
 endif
 
 ifeq ($(CORE), POWER9)
 ifneq ($(C_COMPILER), PGI)
-CCOMMON_OPT += -O3 -mvsx -fno-fast-math
+CCOMMON_OPT += -Ofast -mvsx -fno-fast-math
 ifeq ($(C_COMPILER), GCC)
 ifneq ($(GCCVERSIONGT4), 1)
 $(warning your compiler is too old to fully support POWER9, getting a newer version of gcc is recommended)
@@ -50,18 +38,19 @@ CCOMMON_OPT += -fast -Mvect=simd -Mcache_align
 endif
 ifneq ($(F_COMPILER), PGI)
 ifeq ($(F_COMPILER), IBM)
-FCOMMON_OPT += -O2 -qrecur -qnosave -qarch=pwr9 -qtune=pwr9 -qfloat=nomaf -qzerosize
+FCOMMON_OPT += -O2 -qrecur -qnosave
 else
-FCOMMON_OPT += -O2 -frecursive -fno-fast-math -mcpu=power9 -mtune=power9
+FCOMMON_OPT += -O2 -frecursive -fno-fast-math
 endif
-
-ifeq ($(F_COMPILER), GFORTRAN)
+ifeq ($(C_COMPILER), GCC)
 ifneq ($(GCCVERSIONGT4), 1)
 $(warning your compiler is too old to fully support POWER9, getting a newer version of gcc is recommended)
 FCOMMON_OPT += -mcpu=power8 -mtune=power8 
 else
 FCOMMON_OPT += -mcpu=power9 -mtune=power9 
 endif
+else
+FCOMMON_OPT += -mcpu=power9 -mtune=power9
 endif
 else
 FCOMMON_OPT += -O2 -Mrecursive
@@ -70,23 +59,19 @@ endif
 
 ifeq ($(CORE), POWER8)
 ifneq ($(C_COMPILER), PGI)
-CCOMMON_OPT += -O3 -mcpu=power8 -mtune=power8 -mvsx  -fno-fast-math
+CCOMMON_OPT += -Ofast -mcpu=power8 -mtune=power8 -mvsx  -fno-fast-math
 else
 CCOMMON_OPT += -fast -Mvect=simd -Mcache_align
 endif
 ifneq ($(F_COMPILER), PGI)
 ifeq ($(OSNAME), AIX)
 ifeq ($(F_COMPILER), IBM)
-FCOMMON_OPT += -O2 -qrecur -qnosave -qarch=pwr8 -qtune=pwr8 -qfloat=nomaf -qzerosize
+FCOMMON_OPT += -O2 -qrecur -qnosave
 else
-FCOMMON_OPT += -O1 -frecursive -mcpu=power8 -mtune=power8 -fno-fast-math
+FCOMMON_OPT += -O1 -frecursive -mcpu=power8 -mtune=power8  -fno-fast-math 
 endif
 else
-ifeq ($(F_COMPILER), IBM)
-FCOMMON_OPT += -O2 -qrecur -qnosave -qarch=pwr8 -qtune=pwr8 -qfloat=nomaf -qzerosize
-else
-FCOMMON_OPT += -O2 -frecursive -mcpu=power8 -mtune=power8 -fno-fast-math
-endif
+FCOMMON_OPT += -O2 -frecursive -mcpu=power8 -mtune=power8  -fno-fast-math 
 endif
 else
 FCOMMON_OPT += -O2 -Mrecursive
@@ -99,34 +84,18 @@ CCOMMON_OPT += -DUSE_OPENMP -fopenmp
 else
 CCOMMON_OPT += -DUSE_OPENMP -mp
 endif
-ifeq ($(F_COMPILER), IBM)
-FCOMMON_OPT += -DUSE_OPENMP 
-else
 ifneq ($(F_COMPILER), PGI)
 FCOMMON_OPT += -DUSE_OPENMP -fopenmp
 else
 FCOMMON_OPT += -DUSE_OPENMP -mp
 endif
 endif
-endif
 
-ifeq ($(C_COMPILER), CLANG)
-CCOMMON_OPT += -fno-integrated-as
-ifeq ($(OSNAME), FreeBSD)
-ifeq ($(CORE), $(filter $(CORE),POWER9 POWER10))
-CCOMMON_OPT += -Wa,-mpwr10
-endif
-endif
-endif
 # workaround for C->FORTRAN ABI violation in LAPACKE
 ifeq ($(F_COMPILER), GFORTRAN)
 FCOMMON_OPT += -fno-optimize-sibling-calls
 endif
 
-ifeq ($(F_COMPILER), FLANGNEW)
-override FCOMMON_OPT := $(filter-out -frecursive,$(FCOMMON_OPT))
-endif
-
 FLAMEPATH	= $(HOME)/flame/lib
 
 #ifeq ($(CORE), CELL)
@@ -156,22 +125,8 @@ endif
 ifdef BINARY64
 
 
-#Skip C/Fortran compiler combination checks in AIX if NO_FORTRAN or ONLY_CBLAS is set
-ifeq ($(filter 1,$(NO_FORTRAN) $(ONLY_CBLAS)),)
-ifeq ($(C_COMPILER)$(F_COMPILER)$(OSNAME), GCCIBMAIX)
-$(error Using GCC and XLF on AIX is not a supported combination.)
-endif
-ifeq ($(C_COMPILER)$(F_COMPILER)$(OSNAME), CLANGGFORTRANAIX)
-$(error Using Clang and gFortran on AIX is not a supported combination.)
-endif
-endif
-
 ifeq ($(OSNAME), AIX)
-ifeq ($(C_COMPILER), GCC)
 CCOMMON_OPT	+= -mpowerpc64 -maix64
-else
-CCOMMON_OPT	+= -m64
-endif
 ifeq ($(COMPILER_F77), g77)
 FCOMMON_OPT	+= -mpowerpc64 -maix64
 endif

Makefile.prebuild

@@ -15,12 +15,6 @@ TARGET_MAKE = Makefile.conf
 TARGET_CONF = config.h
 endif
 
-ifdef USE_PERL
-SCRIPTSUFFIX = .pl
-else
-SCRIPTSUFFIX =
-endif
-
 # CPUIDEMU = ../../cpuid/table.o
 
 ifdef CPUIDEMU
@@ -52,41 +46,17 @@ TARGET_FLAGS = -mips64r6
 endif
 
 ifeq ($(TARGET), C910V)
-TARGET_FLAGS = -march=rv64gcv0p7_zfh_xtheadc -mabi=lp64d
-endif
-
-ifeq ($(TARGET), CK860FV)
-TARGET_FLAGS = -march=ck860v -mcpu=ck860fv -mfdivdu -mhard-float
-endif
-
-ifeq ($(TARGET), x280)
-TARGET_FLAGS = -march=rv64imafdcv_zba_zbb_zfh -mabi=lp64d
-endif
-
-ifeq ($(TARGET), RISCV64_ZVL256B)
-TARGET_FLAGS = -march=rv64imafdcv -mabi=lp64d
-endif
-
-ifeq ($(TARGET), RISCV64_ZVL128B)
-TARGET_FLAGS = -march=rv64imafdcv -mabi=lp64d
-endif
-
-ifeq ($(TARGET), RISCV64_GENERIC)
-TARGET_FLAGS = -march=rv64imafdc -mabi=lp64d
-endif
-
-ifeq ($(TARGET), U74)
-TARGET_FLAGS = -march=rv64imafdc_zba_zbb -mabi=lp64d
+TARGET_FLAGS = -march=rv64gcvxthead -mabi=lp64v
 endif
 
 all: getarch_2nd
 	./getarch_2nd  0 >> $(TARGET_MAKE)
 	./getarch_2nd  1 >> $(TARGET_CONF)
 
-$(TARGET_CONF): c_check$(SCRIPTSUFFIX) f_check$(SCRIPTSUFFIX) getarch
-	./c_check$(SCRIPTSUFFIX) $(TARGET_MAKE) $(TARGET_CONF) "$(CC)" $(TARGET_FLAGS) $(CFLAGS)
+config.h : c_check f_check getarch
+	perl ./c_check $(TARGET_MAKE) $(TARGET_CONF) $(CC) $(TARGET_FLAGS) $(CFLAGS)
 ifneq ($(ONLY_CBLAS), 1)
-	./f_check$(SCRIPTSUFFIX) $(TARGET_MAKE) $(TARGET_CONF) "$(FC)" $(TARGET_FLAGS)
+	perl ./f_check $(TARGET_MAKE) $(TARGET_CONF) $(FC) $(TARGET_FLAGS)
 else
 #When we only build CBLAS, we set NOFORTRAN=2
 	echo "NOFORTRAN=2" >> $(TARGET_MAKE)
@@ -101,11 +71,9 @@ endif
 
 
 getarch : getarch.c cpuid.S dummy $(CPUIDEMU)
-	avx512=$$(./c_check$(SCRIPTSUFFIX) - - "$(CC)" $(TARGET_FLAGS) $(CFLAGS) | grep NO_AVX512); \
-	rv64gv=$$(./c_check$(SCRIPTSUFFIX) - - "$(CC)" $(TARGET_FLAGS) $(CFLAGS) | grep NO_RV64GV); \
-	$(HOSTCC) $(HOST_CFLAGS) $(EXFLAGS) $${avx512:+-D$${avx512}} $${rv64gv:+-D$${rv64gv}} -o $(@F) getarch.c cpuid.S $(CPUIDEMU)
+	$(HOSTCC) $(HOST_CFLAGS) $(EXFLAGS) -o $(@F) getarch.c cpuid.S $(CPUIDEMU)
 
-getarch_2nd : getarch_2nd.c $(TARGET_CONF) dummy
+getarch_2nd : getarch_2nd.c config.h dummy
 ifndef TARGET_CORE
 	$(HOSTCC) -I. $(HOST_CFLAGS) -o $(@F) getarch_2nd.c
 else
@@ -113,5 +81,3 @@ else
 endif
 
 dummy:
-
-.PHONY: dummy

Makefile.riscv64

@@ -1,31 +1,4 @@
 ifeq ($(CORE), C910V)
-CCOMMON_OPT += -march=rv64imafdcv0p7_zfh_xtheadc -mabi=lp64d -mtune=c920
-FCOMMON_OPT += -march=rv64imafdcv0p7_zfh_xtheadc -mabi=lp64d -mtune=c920 -static
-endif
-ifeq ($(CORE), x280)
-CCOMMON_OPT += -march=rv64imafdcv_zba_zbb_zfh_zvl512b -mabi=lp64d 
-FCOMMON_OPT += -march=rv64imafdcv_zba_zbb_zfh -mabi=lp64d -static
-endif
-RISCV64_OPT  = rv64imafdcv
-ifeq ($(BUILD_HFLOAT16), 1)
-RISCV64_OPT := $(RISCV64_OPT)_zvfh_zfh
-endif
-ifeq ($(BUILD_BFLOAT16), 1)
-RISCV64_OPT := $(RISCV64_OPT)_zvfbfwma
-endif
-ifeq ($(CORE), RISCV64_ZVL256B)
-CCOMMON_OPT += -march=$(RISCV64_OPT)_zvl256b -mabi=lp64d
-FCOMMON_OPT += -march=$(RISCV64_OPT) -mabi=lp64d
-endif
-ifeq ($(CORE), RISCV64_ZVL128B)
-CCOMMON_OPT += -march=$(RISCV64_OPT) -mabi=lp64d
-FCOMMON_OPT += -march=$(RISCV64_OPT) -mabi=lp64d
-endif
-ifeq ($(CORE), RISCV64_GENERIC)
-CCOMMON_OPT += -march=rv64imafdc -mabi=lp64d
-FCOMMON_OPT += -march=rv64imafdc -mabi=lp64d
-endif
-ifeq ($(CORE), U74)
-CCOMMON_OPT += -march=rv64imafdc_zba_zbb -mabi=lp64d -mtune=sifive-u74
-FCOMMON_OPT += -march=rv64imafdc_zba_zbb -mabi=lp64d -mtune=sifive-u74
+CCOMMON_OPT += -march=rv64gcvxthead -mabi=lp64v
+FCOMMON_OPT += -march=rv64gcvxthead -mabi=lp64v -static
 endif

Makefile.rule

@@ -3,17 +3,12 @@
 #
 
 # This library's version
-VERSION = 0.3.34.dev
+VERSION = 0.3.20
 
-# If you set this prefix, the library name will be lib$(LIBNAMEPREFIX)openblas.a
-# and lib$(LIBNAMEPREFIX)openblas.so, with a matching soname in the shared library
-#
-# LIBNAMEPREFIX = scipy
-
-# If you set the suffix, the library name will be libopenblas$(LIBNAMESUFFIX).a
-# and libopenblas$(LIBNAMESUFFIX).so. Meanwhile, the soname in shared library
-# is libopenblas$(LIBNAMESUFFIX).so.0.
-# LIBNAMESUFFIX = _omp
+# If you set the suffix, the library name will be libopenblas_$(LIBNAMESUFFIX).a
+# and libopenblas_$(LIBNAMESUFFIX).so. Meanwhile, the soname in shared library
+# is libopenblas_$(LIBNAMESUFFIX).so.0.
+# LIBNAMESUFFIX = omp
 
 # You can specify the target architecture, otherwise it's
 # automatically detected.
@@ -134,17 +129,8 @@ VERSION = 0.3.34.dev
 # Build LAPACK Deprecated functions since LAPACK 3.6.0
 BUILD_LAPACK_DEPRECATED = 1
 
-# The variable type assumed for the length of character arguments when passing
-# data between Fortran LAPACK and C BLAS (defaults to "size_t", but older GCC
-# versions used "int"). Mismatches will not cause runtime failures but may result
-# in build warnings or errors when building with link-time optimization (LTO)
-# LAPACK_STRLEN=int
-
 # Build RecursiveLAPACK on top of LAPACK
 # BUILD_RELAPACK = 1
-# Have RecursiveLAPACK actually replace standard LAPACK routines instead of 
-# just adding its equivalents with a RELAPACK_ prefix
-# RELAPACK_REPLACE = 1
 
 # If you want to use the legacy threaded Level 3 implementation.
 # USE_SIMPLE_THREADED_LEVEL3 = 1
@@ -179,10 +165,6 @@ NO_AFFINITY = 1
 # If you are compiling for Linux and you have more than 16 numa nodes or more than 256 cpus
 # BIGNUMA = 1
 
-# If you are compiling for an embedded system ("bare metal") like Cortex M series
-# Note that you will have to provide implementations of malloc() and free() in this case
-# EMBEDDED = 1
-
 # Don't use AVX kernel on Sandy Bridge. It is compatible with old compilers
 # and OS. However, the performance is low.
 # NO_AVX = 1
@@ -225,17 +207,7 @@ NO_AFFINITY = 1
 # to the user space. If bigphysarea is enabled, it will use it.
 # DEVICEDRIVER_ALLOCATION = 1
 
-# Use large page allocation (called hugepage support in Linux context)
-# for the thread buffers (with access by shared memory operations)
-# HUGETLB_ALLOCATION = 1
-
-# Use large page allocation called hugepages in Linux) based on mmap accessing
-# a memory-backed pseudofile (requires hugetlbfs to be mounted in the system,
-# the example below has it mounted on /hugepages. OpenBLAS will create the backing
-# file as gotoblas.processid in that path)
-# HUGETLBFILE_ALLOCATION = /hugepages
-
-# If you need to synchronize FP CSR between threads (for x86/x86_64 and aarch64 only).
+# If you need to synchronize FP CSR between threads (for x86/x86_64 only).
 # CONSISTENT_FPCSR = 1
 
 # If any gemm argument m, n or k is less or equal this threshold, gemm will be execute
@@ -290,10 +262,10 @@ COMMON_PROF = -pg
 # This is mostly intended as a developer feature to spot regressions, but users and
 # package maintainers can enable this if they have doubts about the thread safety of
 # the library, given the configuration in this file.
-# By default, the thread safety testers launch many concurrent calculations at
-# the same time.
+# By default, the thread safety tester launches 52 concurrent calculations at the same
+# time.
 #
-# Please note that the tests use ~1300 MiB of RAM for the DGEMM test.
+# Please note that the test uses ~1300 MiB of RAM for the DGEMM test.
 #
 # The test requires CBLAS to be built, a C++11 capable compiler and the presence of
 # an OpenMP implementation. If you are cross-compiling this test will probably not
@@ -308,8 +280,6 @@ COMMON_PROF = -pg
 # If you want to enable the experimental BFLOAT16 support
 # BUILD_BFLOAT16 = 1
 
-# If you want to enable the experimental HFLOAT16 support
-# BUILD_HFLOAT16 = 1
 
 # Set the thread number threshold beyond which the job array for the threaded level3 BLAS
 # will be allocated on the heap rather than the stack. (This array alone requires 

Makefile.system

@@ -9,10 +9,6 @@ ifndef TOPDIR
 TOPDIR = . 
 endif
 
-ifndef RELAPACK_REPLACE
-RELAPACK_REPLACE=0
-endif
-
 # we need to use the host system's architecture for getarch compile options even especially when cross-compiling
 HOSTARCH := $(shell uname -m)
 ifeq ($(HOSTARCH), amd64)
@@ -194,7 +190,7 @@ ifeq ($(TARGET_CORE), EXCAVATOR)
 GETARCH_FLAGS := -DFORCE_BARCELONA
 endif
 ifeq ($(TARGET_CORE), ZEN)
-GETARCH_FLAGS := -DFORCE_NEHALEM
+GETARCH_FLAGS := -DFORCE_BARCELONA
 endif
 endif
 
@@ -247,11 +243,6 @@ NO_PARALLEL_MAKE=0
 endif
 GETARCH_FLAGS	+= -DNO_PARALLEL_MAKE=$(NO_PARALLEL_MAKE)
 
-ifndef MAKE_NB_JOBS
-ifneq (,$(patsubst -j%,%,$(filter -j%,$(MAKEFLAGS))))
-MAKE_NB_JOBS=-1
-endif
-endif
 ifdef MAKE_NB_JOBS
 GETARCH_FLAGS += -DMAKE_NB_JOBS=$(MAKE_NB_JOBS)
 endif
@@ -270,55 +261,26 @@ endif
 #For small matrix optimization
 ifeq ($(ARCH), x86_64)
 SMALL_MATRIX_OPT = 1
-else ifeq ($(ARCH), power)
-SMALL_MATRIX_OPT = 1
-BUILD_BFLOAT16 = 1
-else ifeq ($(ARCH), arm64)
-SMALL_MATRIX_OPT = 1
-BUILD_BFLOAT16 = 1
-endif
-ifeq ($(ARCH), loongarch64)
+else ifeq ($(CORE), POWER10)
 SMALL_MATRIX_OPT = 1
 endif
-ifeq ($(ARCH), arm64)
-GEMM_GEMV_FORWARD = 1
-SBGEMM_GEMV_FORWARD = 1
-BGEMM_GEMV_FORWARD = 1
-endif
-ifeq ($(ARCH), riscv64)
-GEMM_GEMV_FORWARD = 1
-endif
-ifeq ($(ARCH), power)
-GEMM_GEMV_FORWARD = 1
-SBGEMM_GEMV_FORWARD = 1
-endif
-
 ifeq ($(SMALL_MATRIX_OPT), 1)
 CCOMMON_OPT += -DSMALL_MATRIX_OPT
 endif
-ifneq ($(ONLY_CBLAS), 1)
-ifeq ($(GEMM_GEMV_FORWARD), 1)
-CCOMMON_OPT += -DGEMM_GEMV_FORWARD
-endif
-ifeq ($(SBGEMM_GEMV_FORWARD), 1)
-CCOMMON_OPT += -DSBGEMM_GEMV_FORWARD
-endif
-ifeq ($(BGEMM_GEMV_FORWARD), 1)
-CCOMMON_OPT += -DBGEMM_GEMV_FORWARD
-endif
-endif
 
 # This operation is expensive, so execution should be once.
 ifndef GOTOBLAS_MAKEFILE
 export GOTOBLAS_MAKEFILE = 1
 
+# Determine if the assembler is GNU Assembler
+HAVE_GAS := $(shell $(AS) -v < /dev/null 2>&1 | grep GNU 2>&1 >/dev/null ; echo $$?)
+GETARCH_FLAGS += -DHAVE_GAS=$(HAVE_GAS)
+
 # Generating Makefile.conf and config.h
 DUMMY := $(shell $(MAKE) -C $(TOPDIR) -f Makefile.prebuild CC="$(CC)" FC="$(FC)" HOSTCC="$(HOSTCC)" HOST_CFLAGS="$(GETARCH_FLAGS)" CFLAGS="$(CFLAGS)" BINARY=$(BINARY) USE_OPENMP=$(USE_OPENMP) DYNAMIC_ARCH=$(DYNAMIC_ARCH) TARGET_CORE=$(TARGET_CORE) ONLY_CBLAS=$(ONLY_CBLAS) TARGET=$(TARGET) all)
 
-endif
-
 ifndef TARGET_CORE
--include $(TOPDIR)/Makefile.conf
+include $(TOPDIR)/Makefile.conf
 else
 HAVE_NEON=
 HAVE_VFP=
@@ -336,10 +298,10 @@ HAVE_SSE5=
 HAVE_AVX=
 HAVE_AVX2=
 HAVE_FMA3=
-HAVE_SME=
 include $(TOPDIR)/Makefile_kernel.conf
 endif
 
+endif
 
 ifndef NUM_PARALLEL
 NUM_PARALLEL = 1
@@ -390,7 +352,7 @@ OBJCONV = $(CROSS_SUFFIX)objconv
 
 # When fortran support was either not detected or actively deselected, only build BLAS.
 ifeq ($(NOFORTRAN), 1)
-C_LAPACK = 1
+NO_LAPACK = 1
 override FEXTRALIB = 
 endif
 
@@ -401,11 +363,8 @@ GCCVERSIONGT5 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \> 5)
 GCCVERSIONGTEQ7 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 7)
 GCCVERSIONGTEQ8 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 8)
 GCCVERSIONGTEQ9 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 9)
-GCCVERSIONGTEQ10 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 10)
 GCCVERSIONGTEQ11 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 11)
-GCCVERSIONGTEQ12 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 12)
-GCCVERSIONGTEQ13 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 13)
-GCCVERSIONGTEQ14 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 14)
+GCCVERSIONGTEQ10 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 10)
 # Note that the behavior of -dumpversion is compile-time-configurable for
 # gcc-7.x and newer. Use -dumpfullversion there
 ifeq ($(GCCVERSIONGTEQ7),1)
@@ -419,40 +378,15 @@ GCCMINORVERSIONGTEQ4 := $(shell expr `$(CC) $(GCCDUMPVERSION_PARAM) | cut -f2 -d
 GCCMINORVERSIONGTEQ7 := $(shell expr `$(CC) $(GCCDUMPVERSION_PARAM) | cut -f2 -d.` \>= 7)
 endif
 
-ifeq ($(C_COMPILER), CLANG)
-CLANGVERSIONGTEQ9 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 9)
-CLANGVERSIONGTEQ12 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \>= 12)
-ifeq ($(F_COMPILER), GFORTRAN)
-GCCVERSIONGT4 := $(shell expr `$(CC) -dumpversion | cut -f1 -d.` \> 4)
-endif
-endif
-
 #
 #  OS dependent settings
 #
 
 ifeq ($(OSNAME), Darwin)
 ifndef MACOSX_DEPLOYMENT_TARGET
-ifeq ($(ARCH), arm64)
-export MACOSX_DEPLOYMENT_TARGET=11.0
-export NO_SVE = 1
-# export NO_SME = 1
-else
 export MACOSX_DEPLOYMENT_TARGET=10.8
 endif
-endif
 MD5SUM = md5 -r
-XCVER = $(shell pkgutil --pkg-info=com.apple.pkg.Xcode |awk '/version:/ {print $2}'|cut -d: -f2|cut -f1 -d.)
-ifeq (x$(XCVER)x,xx)
-XCVER = $(shell pkgutil --pkg-info=com.apple.pkg.CLTools_Executables |awk '/version:/ {print $2}'|cut -d: -f2|cut -f1 -d.)
-endif
-ifeq (x$(XCVER), x 15)
-CCOMMON_OPT += -Wl,-ld_classic
-FCOMMON_OPT += -Wl,-ld_classic
-endif
-ifeq ($(shell [ $(XCVER) -ge 16 ] && echo yes),yes)
-override CEXTRALIB := $(filter-out(-lto_library, $(CEXTRALIB))) 
-endif
 endif
 
 ifneq (,$(findstring $(OSNAME), FreeBSD OpenBSD DragonFly))
@@ -465,7 +399,7 @@ endif
 
 ifeq ($(OSNAME), Linux)
 EXTRALIB	+= -lm
-#NO_EXPRECISION = 1
+NO_EXPRECISION = 1
 endif
 
 ifeq ($(OSNAME), Android)
@@ -476,8 +410,8 @@ ifeq ($(OSNAME), AIX)
 EXTRALIB	+= -lm
 endif
 
-ifeq ($(OSNAME), $(filter $(OSNAME),FreeBSD OpenBSD NetBSD DragonFly))
-ifeq ($(ARCH), $(filter $(ARCH),arm arm64 power))
+ifeq ($(OSNAME), FreeBSD)
+ifeq ($(ARCH), $(filter $(ARCH),arm arm64))
 EXTRALIB	+= -lm
 endif
 endif
@@ -591,7 +525,7 @@ NO_BINARY_MODE	= 1
 endif
 
 ifeq ($(CORE), generic)
-#NO_EXPRECISION = 1
+NO_EXPRECISION = 1
 endif
 
 ifndef NO_EXPRECISION
@@ -600,13 +534,11 @@ ifeq ($(F_COMPILER), GFORTRAN)
 ifeq ($(C_COMPILER), $(filter $(C_COMPILER),GCC LSB))
 EXPRECISION	= 1
 CCOMMON_OPT	+= -DEXPRECISION -m128bit-long-double
-CCOMMON_OPT	+= -fvisibility=hidden
 FCOMMON_OPT	+= -m128bit-long-double
 endif
 ifeq ($(C_COMPILER), CLANG)
 EXPRECISION	= 1
 CCOMMON_OPT	+= -DEXPRECISION
-CCOMMON_OPT	+= -fvisibility=hidden
 FCOMMON_OPT	+= -m128bit-long-double
 endif
 endif
@@ -616,7 +548,7 @@ endif
 ifeq ($(ARCH), x86_64)
 
 ifeq ($(CORE), generic)
-#NO_EXPRECISION = 1
+NO_EXPRECISION = 1
 endif
 
 ifndef NO_EXPRECISION
@@ -625,13 +557,11 @@ ifeq ($(F_COMPILER), GFORTRAN)
 ifeq ($(C_COMPILER), $(filter $(C_COMPILER),GCC LSB))
 EXPRECISION	= 1
 CCOMMON_OPT	+= -DEXPRECISION -m128bit-long-double
-CCOMMON_OPT	+= -fvisibility=hidden
 FCOMMON_OPT	+= -m128bit-long-double
 endif
 ifeq ($(C_COMPILER), CLANG)
 EXPRECISION	= 1
 CCOMMON_OPT	+= -DEXPRECISION
-CCOMMON_OPT	+= -fvisibility=hidden
 FCOMMON_OPT	+= -m128bit-long-double
 endif
 endif
@@ -657,9 +587,6 @@ endif
 
 ifeq ($(C_COMPILER), CLANG)
 CCOMMON_OPT    += -fopenmp
-ifeq ($(F_COMPILER), GFORTRAN)
-FEXTRALIB := $(subst -lgomp,-lomp,$(FEXTRALIB))
-endif
 endif
 
 ifeq ($(C_COMPILER), INTEL)
@@ -708,7 +635,7 @@ DYNAMIC_CORE += HASWELL ZEN
 endif
 ifneq ($(NO_AVX512), 1)
 ifneq ($(NO_AVX2), 1)
-DYNAMIC_CORE += SKYLAKEX COOPERLAKE SAPPHIRERAPIDS
+DYNAMIC_CORE += SKYLAKEX COOPERLAKE
 endif
 endif
 endif
@@ -725,40 +652,18 @@ ifeq ($(ARCH), arm64)
 DYNAMIC_CORE =  ARMV8
 DYNAMIC_CORE += CORTEXA53
 DYNAMIC_CORE += CORTEXA57
+DYNAMIC_CORE += CORTEXA72
+DYNAMIC_CORE += CORTEXA73
 DYNAMIC_CORE += NEOVERSEN1
-ifneq ($(NO_SVE), 1)
 DYNAMIC_CORE += NEOVERSEV1
 DYNAMIC_CORE += NEOVERSEN2
-DYNAMIC_CORE += ARMV8SVE
-DYNAMIC_CORE += A64FX
-endif
-ifneq ($(NO_SME), 1)
-DYNAMIC_CORE += ARMV9SME
-ifeq ($(OSNAME), Darwin)
-ifneq ($(C_COMPILER), GCC)
-DYNAMIC_CORE += VORTEXM4
-endif
-endif
-endif
+DYNAMIC_CORE += CORTEXA55
+DYNAMIC_CORE += FALKOR
 DYNAMIC_CORE += THUNDERX
 DYNAMIC_CORE += THUNDERX2T99
 DYNAMIC_CORE += TSV110
 DYNAMIC_CORE += EMAG8180
 DYNAMIC_CORE += THUNDERX3T110
-
-ifeq ($(OSNAME), Darwin)
-DYNAMIC_CORE =  ARMV8
-DYNAMIC_CORE += NEOVERSEN1
-ifneq ($(NO_SME), 1)
-DYNAMIC_CORE += ARMV9SME
-ifeq ($(OSNAME), Darwin)
-ifneq ($(C_COMPILER), GCC)
-DYNAMIC_CORE += VORTEXM4
-endif
-endif
-endif
-endif
-
 ifdef DYNAMIC_LIST
 override DYNAMIC_CORE = ARMV8 $(DYNAMIC_LIST)
 XCCOMMON_OPT = -DDYNAMIC_LIST -DDYN_ARMV8
@@ -767,27 +672,7 @@ endif
 endif
 
 ifeq ($(ARCH), mips64)
-DYNAMIC_CORE = LOONGSON3R3 LOONGSON3R4 MIPS64_GENERIC
-ifdef DYNAMIC_LIST
-override DYNAMIC_CORE = MIPS64_GENERIC $(DYNAMIC_LIST)
-XCCOMMON_OPT = -DDYNAMIC_LIST -DDYN_MIPS64_GENERIC
-XCCOMMON_OPT += $(foreach dcore,$(DYNAMIC_LIST),-DDYN_$(dcore))
-endif
-endif
-
-ifeq ($(ARCH), loongarch64)
-DYNAMIC_CORE = LA64_GENERIC LA264 LA464
-endif
-
-ifeq ($(ARCH), riscv64)
-DYNAMIC_CORE = RISCV64_GENERIC
-DYNAMIC_CORE += RISCV64_ZVL128B
-DYNAMIC_CORE += RISCV64_ZVL256B
-ifdef DYNAMIC_LIST
-override DYNAMIC_CORE = RISCV64_GENERIC $(DYNAMIC_LIST)
-XCCOMMON_OPT = -DDYNAMIC_LIST -DDYN_RISCV64_GENERIC
-XCCOMMON_OPT += $(foreach dcore,$(DYNAMIC_LIST),-DDYN_$(dcore))
-endif
+DYNAMIC_CORE = LOONGSON3R3 LOONGSON3R4
 endif
 
 ifeq ($(ARCH), zarch)
@@ -838,11 +723,7 @@ DYNAMIC_CORE += POWER9
 else
 $(info, OpenBLAS: Your gcc version is too old to build the POWER9 kernels.)
 endif
-ifeq ($(OSNAME), AIX)
-LDVERSIONGTEQ35 := 1
-else
 LDVERSIONGTEQ35 := $(shell expr `$(CC) -Wl,--version 2> /dev/null | head -1 | cut -f2 -d "." | cut -f1 -d "-"` \>= 35)
-endif
 ifeq ($(GCCVERSIONGTEQ11)$(LDVERSIONGTEQ35), 11)
 DYNAMIC_CORE += POWER10
 CCOMMON_OPT += -DHAVE_P10_SUPPORT
@@ -873,8 +754,8 @@ BINARY_DEFINED	= 1
 
 ifeq ($(F_COMPILER), GFORTRAN)
 ifeq ($(C_COMPILER), GCC)
-EXPRECISION	= 1
-CCOMMON_OPT	+= -DEXPRECISION
+# EXPRECISION	= 1
+# CCOMMON_OPT	+= -DEXPRECISION
 endif
 endif
 endif
@@ -892,12 +773,8 @@ ifeq ($(ARCH), arm)
 NO_BINARY_MODE  = 1
 BINARY_DEFINED  = 1
 
-ifneq ($(EMBEDDED), 1)
 CCOMMON_OPT += -marm
 FCOMMON_OPT += -marm
-else
-CCOMMON_OPT += -DOS_EMBEDDED -mthumb -mcpu=cortex-m4 -mfloat-abi=hard -mfpu=fpv4-sp-d16
-endif
 
 # If softfp abi is mentioned on the command line, force it.
 ifeq ($(ARM_SOFTFP_ABI), 1)
@@ -919,7 +796,7 @@ NO_BINARY_MODE  = 1
 BINARY_DEFINED  = 1
 ifdef INTERFACE64
 ifneq ($(INTERFACE64), 0)
-ifeq ($(F_COMPILER), $(filter $(F_COMPILER),GFORTRAN FLANGNEW))
+ifeq ($(F_COMPILER), GFORTRAN)
 FCOMMON_OPT +=  -fdefault-integer-8
 endif
 ifeq ($(F_COMPILER), FLANG)
@@ -932,37 +809,13 @@ endif
 ifeq ($(ARCH), riscv64)
 NO_BINARY_MODE  = 1
 BINARY_DEFINED  = 1
-ifdef INTERFACE64
-ifneq ($(INTERFACE64), 0)
-ifeq ($(F_COMPILER), $(filter $(F_COMPILER),GFORTRAN FLANGNEW))
-FCOMMON_OPT +=  -fdefault-integer-8
-endif
-ifeq ($(F_COMPILER), FLANG)
-FCOMMON_OPT += -i8
-endif
-endif
-endif
 endif
 
 ifeq ($(ARCH), loongarch64)
 NO_BINARY_MODE  = 1
 BINARY_DEFINED  = 1
-ifdef INTERFACE64
-ifneq ($(INTERFACE64), 0)
-ifeq ($(F_COMPILER), $(filter $(F_COMPILER),GFORTRAN FLANGNEW))
-FCOMMON_OPT +=  -fdefault-integer-8
-endif
-ifeq ($(F_COMPILER), FLANG)
-FCOMMON_OPT += -i8
-endif
-endif
-endif
 endif
 
-ifeq ($(ARCH), csky)
-NO_BINARY_MODE	= 1
-BINARY_DEFINED	= 1
-endif
 
 #
 #  C Compiler dependent settings
@@ -994,12 +847,7 @@ CCOMMON_OPT += -mabi=32
 BINARY_DEFINED = 1
 endif
 
-ifneq (, $(filter $(CORE), MIPS64_GENERIC))
-CCOMMON_OPT += -DNO_MSA
-FCOMMON_OPT += -DNO_MSA
-endif
-
-ifneq (, $(filter $(CORE),LOONGSON3R3 LOONGSON3R4))
+ifeq ($(CORE), $(filter $(CORE),LOONGSON3R3 LOONGSON3R4))
 CCOMMON_OPT += -march=loongson3a
 FCOMMON_OPT += -march=loongson3a
 endif
@@ -1039,17 +887,9 @@ BINARY_DEFINED = 1
 endif
 
 ifeq ($(ARCH), loongarch64)
-LA64_ABI=$(shell $(CC) -mabi=lp64d -c $(TOPDIR)/cpuid_loongarch64.c -o /dev/null > /dev/null 2> /dev/null && echo lp64d)
-LA64_ARCH=$(shell $(CC) -march=loongarch64 -c $(TOPDIR)/cpuid_loongarch64.c -o /dev/null > /dev/null 2> /dev/null && echo loongarch64)
-ifneq ($(LA64_ABI), lp64d)
-LA64_ABI=lp64
-endif
-ifneq ($(LA64_ARCH), loongarch64)
-CCOMMON_OPT += -mabi=$(LA64_ABI)
-FCOMMON_OPT += -mabi=$(LA64_ABI)
-else
-CCOMMON_OPT += -march=loongarch64 -mabi=$(LA64_ABI)
-FCOMMON_OPT += -march=loongarch64 -mabi=$(LA64_ABI)
+ifeq ($(CORE), LOONGSON3R5)
+CCOMMON_OPT += -march=loongarch64 -mabi=lp64
+FCOMMON_OPT += -march=loongarch64 -mabi=lp64
 endif
 endif
 
@@ -1085,19 +925,16 @@ endif
 endif
 ifdef BINARY64
 ifeq ($(ARCH), x86_64)
-ifeq (,$(findstring tp,$(CFLAGS)))
 ifneq ($(NEWPGI2),1)
 CCOMMON_OPT += -tp p7-64
 else
 CCOMMON_OPT += -tp px
 endif
-endif
 ifneq ($(NEWPGI),1)
 CCOMMON_OPT +=  -D__MMX__ -Mnollvm
 endif
 else
 ifeq ($(ARCH), power)
-ifeq (,$(findstring tp,$(CFLAGS)))
 ifeq ($(CORE), POWER8)
 CCOMMON_OPT += -tp pwr8
 endif
@@ -1106,17 +943,14 @@ CCOMMON_OPT += -tp pwr9
 endif
 endif
 endif
-endif
 else
 ifneq ($(NEWPGI2),1)
-ifeq (,$(findstring tp,$(CFLAGS)))
 CCOMMON_OPT += -tp p7
 else
 CCOMMON_OPT += -tp px
 endif
 endif
 endif
-endif
 
 ifeq ($(C_COMPILER), PATHSCALE)
 ifdef BINARY64
@@ -1199,23 +1033,17 @@ endif
 endif
 endif
 
-ifeq ($(F_COMPILER), $(filter $(F_COMPILER),GFORTRAN FLANGNEW))
-CCOMMON_OPT += -DF_INTERFACE_GFORT
 ifeq ($(F_COMPILER), GFORTRAN)
+CCOMMON_OPT += -DF_INTERFACE_GFORT
 FCOMMON_OPT += -Wall
 # make single-threaded LAPACK calls thread-safe #1847
 FCOMMON_OPT += -frecursive
 # work around ABI problem with passing single-character arguments
 FCOMMON_OPT += -fno-optimize-sibling-calls
 #Don't include -lgfortran, when NO_LAPACK=1 or lsbcc
-ifneq ($(NOFORTRAN), 1)
-ifneq ($(NOFORTRAN), 2)
 ifneq ($(NO_LAPACK), 1)
 EXTRALIB += -lgfortran
 endif
-endif
-endif
-endif
 ifdef NO_BINARY_MODE
 ifeq ($(ARCH), $(filter $(ARCH),mips64))
 ifdef BINARY64
@@ -1226,13 +1054,6 @@ endif
 else ifeq ($(ARCH), $(filter $(ARCH),mips))
 FCOMMON_OPT += -mabi=32
 endif
-ifeq ($(ARCH), $(filter $(ARCH),loongarch64))
-ifdef INTERFACE64
-ifneq ($(INTERFACE64), 0)
-FCOMMON_OPT +=  -fdefault-integer-8
-endif
-endif
-endif
 else
 ifdef BINARY64
 ifneq ($(OSNAME), AIX)
@@ -1278,10 +1099,6 @@ endif
 
 ifeq ($(F_COMPILER), IBM)
 CCOMMON_OPT += -DF_INTERFACE_IBM
-FEXTRALIB += -lxlf90
-ifeq ($(C_COMPILER), $(filter $(C_COMPILER),GCC CLANG))
-FCOMMON_OPT += -qextname -qzerosize
-endif
 # FCOMMON_OPT	+= -qarch=440
 ifdef BINARY64
 FCOMMON_OPT += -q64
@@ -1293,6 +1110,9 @@ endif
 else
 FCOMMON_OPT += -q32
 endif
+ifeq ($(USE_OPENMP), 1)
+FCOMMON_OPT += -openmp
+endif
 endif
 
 ifeq ($(F_COMPILER), PGI)
@@ -1359,6 +1179,7 @@ FCOMMON_OPT += -i8
 endif
 endif
 endif
+
 ifeq ($(ARCH), $(filter $(ARCH),mips64 mips))
 ifndef BINARY64
 FCOMMON_OPT += -n32
@@ -1368,9 +1189,11 @@ endif
 ifeq ($(CORE), LOONGSON3R3)
 FCOMMON_OPT += -loongson3 -static
 endif
+
 ifeq ($(CORE), LOONGSON3R4)
 FCOMMON_OPT += -loongson3 -static
 endif
+
 else
 ifndef BINARY64
 FCOMMON_OPT += -m32
@@ -1378,6 +1201,7 @@ else
 FCOMMON_OPT += -m64
 endif
 endif
+
 ifeq ($(USE_OPENMP), 1)
 FEXTRALIB   += -lstdc++
 FCOMMON_OPT += -mp
@@ -1385,6 +1209,7 @@ endif
 endif
 
 ifeq ($(C_COMPILER), OPEN64)
+
 ifeq ($(ARCH), $(filter $(ARCH),mips64 mips))
 ifndef BINARY64
 CCOMMON_OPT += -n32
@@ -1394,10 +1219,13 @@ endif
 ifeq ($(CORE), LOONGSON3R3)
 CCOMMON_OPT += -loongson3 -static
 endif
+
 ifeq ($(CORE), LOONGSON3R4)
 CCOMMON_OPT += -loongson3 -static
 endif
+
 else
+
 ifndef BINARY64
 CCOMMON_OPT += -m32
 else
@@ -1443,19 +1271,6 @@ FCOMMON_OPT += -openmp
 endif
 endif
 
-ifeq ($(F_COMPILER), CRAY)
-CCOMMON_OPT += -DF_INTERFACE_INTEL
-FCOMMON_OPT += -hnopattern
-ifdef INTERFACE64
-ifneq ($(INTERFACE64), 0)
-FCOMMON_OPT += -s integer64
-endif
-endif
-ifneq ($(USE_OPENMP), 1)
-FCOMMON_OPT += -O noomp
-endif
-endif
-
 ifdef BINARY64
 ifdef INTERFACE64
 ifneq ($(INTERFACE64), 0)
@@ -1475,8 +1290,6 @@ ifeq ($(F_COMPILER), SUN)
 FCOMMON_OPT  += -pic
 else ifeq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -PIC
-else ifeq ($(F_COMPILER), IBM)
-FCOMMON_OPT += -qpic=large
 else
 FCOMMON_OPT += -fPIC
 endif
@@ -1490,10 +1303,6 @@ ifeq ($(DYNAMIC_OLDER), 1)
 CCOMMON_OPT	+= -DDYNAMIC_OLDER
 endif
 
-ifeq ($(C_LAPACK), 1)
-CCOMMON_OPT	+= -DC_LAPACK
-endif
-
 ifeq ($(NO_LAPACK), 1)
 CCOMMON_OPT	+= -DNO_LAPACK
 #Disable LAPACK C interface
@@ -1520,14 +1329,6 @@ ifeq ($(NO_AVX512), 1)
 CCOMMON_OPT	+= -DNO_AVX512
 endif
 
-ifeq ($(NO_SVE), 1)
-CCOMMON_OPT     += -DNO_SVE
-endif
-
-ifeq ($(NO_SME), 1)
-CCOMMON_OPT     += -DNO_SME
-endif
-
 ifdef SMP
 CCOMMON_OPT	+= -DSMP_SERVER
 
@@ -1589,9 +1390,6 @@ endif
 ifeq ($(BUILD_BFLOAT16), 1)
 CCOMMON_OPT += -DBUILD_BFLOAT16
 endif
-ifeq ($(BUILD_HFLOAT16), 1)
-CCOMMON_OPT += -DBUILD_HFLOAT16
-endif
 ifeq ($(BUILD_SINGLE), 1)
 CCOMMON_OPT += -DBUILD_SINGLE=1
 endif
@@ -1619,28 +1417,16 @@ ifndef LIBSONAMEBASE
 LIBSONAMEBASE = openblas
 endif
 
-ifndef LIBNAMEPREFIX
-LIBNAMEPREFIX =
-endif
-
-SYMPREFIX=$(SYMBOLPREFIX)
-ifeq ($(SYMBOLPREFIX),$(LIBNAMEPREFIX))
-SYMPREFIX=
-endif
-SYMSUFFIX=$(SYMBOLSUFFIX)
-ifeq ($(SYMBOLSUFFIX),$(LIBNAMESUFFIX))
-SYMSUFFIX=
-endif
 ifndef LIBNAMESUFFIX
-LIBNAMEBASE = $(SYMPREFIX)$(LIBSONAMEBASE)$(SYMSUFFIX)
+LIBNAMEBASE = $(SYMBOLPREFIX)$(LIBSONAMEBASE)$(SYMBOLSUFFIX)
 else
-LIBNAMEBASE = $(SYMPREFIX)$(LIBSONAMEBASE)$(SYMSUFFIX)$(LIBNAMESUFFIX)
+LIBNAMEBASE = $(SYMBOLPREFIX)$(LIBSONAMEBASE)$(SYMBOLSUFFIX)_$(LIBNAMESUFFIX)
 endif
 
 ifeq ($(OSNAME), CYGWIN_NT)
-LIBPREFIX = cyg$(LIBNAMEPREFIX)$(LIBNAMEBASE)
+LIBPREFIX = cyg$(LIBNAMEBASE)
 else
-LIBPREFIX = lib$(LIBNAMEPREFIX)$(LIBNAMEBASE)
+LIBPREFIX = lib$(LIBNAMEBASE)
 endif
 
 KERNELDIR	= $(TOPDIR)/kernel/$(ARCH)
@@ -1652,11 +1438,7 @@ ifneq ($(C_COMPILER), SUN)
 CCOMMON_OPT     += -UASMNAME -UASMFNAME -UNAME -UCNAME -UCHAR_NAME -UCHAR_CNAME
 endif
 endif
-ifeq ( ,$(findstring pizfix,$(CEXTRALIB)))
 CCOMMON_OPT	+= -DASMNAME=$(FU)$(*F) -DASMFNAME=$(FU)$(*F)$(BU) -DNAME=$(*F)$(BU) -DCNAME=$(*F) -DCHAR_NAME=\"$(*F)$(BU)\" -DCHAR_CNAME=\"$(*F)\"
-else
-CCOMMON_OPT	+= -DASMNAME=$(FU)pizlonated_$(*F) -DASMFNAME=$(FU)pizlonated_$(*F)$(BU) -DNAME=$(*F)$(BU) -DCNAME=$(*F) -DCHAR_NAME=\"$(*F)$(BU)\" -DCHAR_CNAME=\"$(*F)\"
-endif
 
 ifeq ($(CORE), PPC440)
 CCOMMON_OPT	+= -DALLOC_QALLOC
@@ -1676,13 +1458,6 @@ NO_AFFINITY = 1
 endif
 endif
 
-ifeq ($(ARCH), POWER)
-ifeq ($(DEBUG), 1)
-CCOMMON_OPT := $(filter-out -O%, $(CCOMMON_OPT)) -O0
-FCOMMON_OPT := $(filter-out -O%, $(FCOMMON_OPT)) -O0
-endif
-endif
-
 ifdef NO_AFFINITY
 ifeq ($(NO_AFFINITY), 0)
 override undefine NO_AFFINITY
@@ -1695,23 +1470,13 @@ ifdef FUNCTION_PROFILE
 CCOMMON_OPT	+= -DFUNCTION_PROFILE
 endif
 
-ifdef SHMEM_ALLOCATION
-ifneq ($(SHMEM_ALLOCATION), 0)
-CCOMMON_OPT	+= -DALLOC_SHM
-endif
-endif
-
 ifdef HUGETLB_ALLOCATION
-ifneq ($(HUGETLB_ALLOCATION), 0)
 CCOMMON_OPT	+= -DALLOC_HUGETLB
 endif
-endif
 
 ifdef HUGETLBFILE_ALLOCATION
-ifneq ($(HUGETLBFILE_ALLOCATION), 0)
 CCOMMON_OPT	+= -DALLOC_HUGETLBFILE -DHUGETLB_FILE_NAME=$(HUGETLBFILE_ALLOCATION)
 endif
-endif
 
 ifdef STATIC_ALLOCATION
 CCOMMON_OPT	+= -DALLOC_STATIC
@@ -1767,13 +1532,11 @@ override FFLAGS     += $(COMMON_OPT) $(FCOMMON_OPT)
 override FPFLAGS    += $(FCOMMON_OPT) $(COMMON_PROF)
 #MAKEOVERRIDES =
 
-ifeq ($(NEED_PIC), 1)
+ifdef NEED_PIC
 ifeq (,$(findstring PIC,$(FFLAGS)))
-ifneq ($(F_COMPILER),IBM)
 override FFLAGS += -fPIC
 endif
 endif
-endif
 
 #For LAPACK Fortran codes.
 #Disable -fopenmp for LAPACK Fortran codes on Windows.
@@ -1787,15 +1550,6 @@ endif
 
 ifeq ($(F_COMPILER),NAG)
 LAPACK_FFLAGS := $(filter-out -msse3 -mssse3 -msse4.1 -mavx -mavx2 -mskylake-avx512 ,$(FFLAGS))
-override FFLAGS := $(filter-out -msse3 -mssse3 -msse4.1 -mavx -mavx2 -mskylake-avx512 ,$(FFLAGS))
-endif
-ifeq ($(F_COMPILER),CRAY)
-LAPACK_FFLAGS := $(filter-out -msse3 -mssse3 -msse4.1 -mavx -mavx2 -mskylake-avx512 ,$(FFLAGS))
-override FFLAGS := $(filter-out -msse3 -mssse3 -msse4.1 -mavx -mavx2 -mskylake-avx512 ,$(FFLAGS))
-endif
-ifeq ($(F_COMPILER),FLANGNEW)
-LAPACK_FFLAGS := $(filter-out -m32 -m64 -msse3 -mssse3 -msse4.1 -mavx -mavx2 -mskylake-avx512 -mtune=% -mabi=% ,$(FFLAGS))
-override FFLAGS := $(filter-out -m32 -m64 -msse3 -mssse3 -msse4.1 -mavx -mavx2 -mskylake-avx512 -mtune=% -mabi=% ,$(FFLAGS))
 endif
 
 LAPACK_CFLAGS = $(CFLAGS)
@@ -1808,7 +1562,6 @@ endif
 
 ifdef OS_WINDOWS
 LAPACK_CFLAGS +=  -DOPENBLAS_OS_WINDOWS
-LAPACK_CFLAGS +=  -DLAPACK_COMPLEX_STRUCTURE
 endif
 ifeq ($(C_COMPILER), LSB)
 LAPACK_CFLAGS +=  -DLAPACK_COMPLEX_STRUCTURE
@@ -1826,14 +1579,6 @@ ifndef LIBSUFFIX
 LIBSUFFIX = a
 endif
 
-ifndef EXE
-ifeq ($(OSNAME), $(filter $(OSNAME),WINNT CYGWIN_NT))
-EXE = .exe
-else
-EXE =
-endif
-endif
-
 ifneq ($(DYNAMIC_ARCH), 1)
 ifndef SMP
 LIBNAME		= $(LIBPREFIX)_$(LIBCORE)$(REVISION).$(LIBSUFFIX)
@@ -1852,14 +1597,14 @@ LIBNAME_P	= $(LIBPREFIX)p$(REVISION)_p.$(LIBSUFFIX)
 endif
 endif
 
-ifeq ($(FIXED_LIBNAME),1)
-	LIBNAME = lib$(LIBNAMEPREFIX)$(LIBSONAMEBASE)$(LIBNAMESUFFIX).$(LIBSUFFIX)
-	LIBNAME_P = lib$(LIBNAMEPREFIX)$(LISOBNAMEBASE)$(LIBNAMESUFFIX)_p.$(LIBSUFFIX)
-endif
 
 LIBDLLNAME   = $(LIBPREFIX).dll
 IMPLIBNAME   = lib$(LIBNAMEBASE).dll.a
+ifneq ($(OSNAME), AIX)
 LIBSONAME    = $(LIBNAME:.$(LIBSUFFIX)=.so)
+else
+LIBSONAME    = $(LIBNAME:.$(LIBSUFFIX)=.a)
+endif
 LIBDYNNAME   = $(LIBNAME:.$(LIBSUFFIX)=.dylib)
 LIBDEFNAME   = $(LIBNAME:.$(LIBSUFFIX)=.def)
 LIBEXPNAME   = $(LIBNAME:.$(LIBSUFFIX)=.exp)
@@ -1916,7 +1661,6 @@ export USE_OPENMP
 export CROSS
 export CROSS_SUFFIX
 export NOFORTRAN
-export C_LAPACK
 export NO_FBLAS
 export EXTRALIB
 export CEXTRALIB
@@ -1940,23 +1684,15 @@ ifndef NO_MSA
   export HAVE_MSA
   export MSA_FLAGS
 endif
-export HAVE_SME
 export KERNELDIR
 export FUNCTION_PROFILE
 export TARGET_CORE
 export NO_AVX512
 export NO_AVX2
 export BUILD_BFLOAT16
-export BUILD_HFLOAT16
-export NO_LSX
-export NO_LASX
 
-export BGEMM_UNROLL_M
-export BGEMM_UNROLL_N
 export SBGEMM_UNROLL_M
 export SBGEMM_UNROLL_N
-export SHGEMM_UNROLL_M
-export SHGEMM_UNROLL_N
 export SGEMM_UNROLL_M
 export SGEMM_UNROLL_N
 export DGEMM_UNROLL_M

Makefile.tail

@@ -1,34 +1,4 @@
-###############################################################################
-# Copyright (c) 2025, The OpenBLAS Project
-# All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. 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.
-# 3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-###############################################################################
-
-BBLASOBJS_P = $(BBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 SBBLASOBJS_P = $(SBBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
-SHBLASPBJS_P = $(SHBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 SBLASOBJS_P = $(SBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 DBLASOBJS_P = $(DBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
 QBLASOBJS_P = $(QBLASOBJS:.$(SUFFIX)=.$(PSUFFIX))
@@ -41,8 +11,8 @@ COMMONOBJS_P = $(COMMONOBJS:.$(SUFFIX)=.$(PSUFFIX))
 
 HPLOBJS_P   = $(HPLOBJS:.$(SUFFIX)=.$(PSUFFIX))
 
-BLASOBJS    = $(SHBLASOBJS) $(BBLASOBJS) $(SBEXTOBJS) $(SBBLASOBJS)  $(SBLASOBJS)   $(DBLASOBJS)   $(CBLASOBJS)   $(ZBLASOBJS) $(CBAUXOBJS)
-BLASOBJS_P  = $(SHBLASPBJS_P) $(BBLASOBJS_P) $(SBEXTOBJS_P) $(SBBLASOBJS_P) $(SBLASOBJS_P) $(DBLASOBJS_P) $(CBLASOBJS_P) $(ZBLASOBJS_P) $(CBAUXOBJS_P)
+BLASOBJS    = $(SBEXTOBJS) $(SBBLASOBJS)  $(SBLASOBJS)   $(DBLASOBJS)   $(CBLASOBJS)   $(ZBLASOBJS) $(CBAUXOBJS)
+BLASOBJS_P  = $(SBEXTOBJS_P) $(SBBLASOBJS_P) $(SBLASOBJS_P) $(DBLASOBJS_P) $(CBLASOBJS_P) $(ZBLASOBJS_P) $(CBAUXOBJS_P)
 
 ifdef EXPRECISION
 BLASOBJS   += $(QBLASOBJS)   $(XBLASOBJS)
@@ -54,8 +24,6 @@ BLASOBJS   += $(QBLASOBJS)   $(XBLASOBJS)
 BLASOBJS_P += $(QBLASOBJS_P) $(XBLASOBJS_P)
 endif
 
-$(SHBLASOBJS) $(SHBLASOBJS_P) : override CFLAGS += -DHFLOAT16 -UDOUBLE  -UCOMPLEX
-$(BBLASOBJS) $(BBLASOBJS_P) : override CFLAGS += -DBFLOAT16 -DBGEMM -UDOUBLE  -UCOMPLEX
 $(SBBLASOBJS) $(SBBLASOBJS_P) : override CFLAGS += -DBFLOAT16 -UDOUBLE  -UCOMPLEX
 $(SBLASOBJS) $(SBLASOBJS_P) : override CFLAGS += -UDOUBLE  -UCOMPLEX
 $(DBLASOBJS) $(DBLASOBJS_P) : override CFLAGS += -DDOUBLE  -UCOMPLEX
@@ -65,8 +33,6 @@ $(ZBLASOBJS) $(ZBLASOBJS_P) : override CFLAGS += -DDOUBLE  -DCOMPLEX
 $(XBLASOBJS) $(XBLASOBJS_P) : override CFLAGS += -DXDOUBLE -DCOMPLEX
 $(SBEXTOBJS) $(SBEXTOBJS_P) : override CFLAGS += -DBFLOAT16 -UDOUBLE  -UCOMPLEX
 
-$(SHBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
-$(BBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(SBBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(SBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)
 $(DBLASOBJS_P) : override CFLAGS += -DPROFILE $(COMMON_PROF)

Makefile.wasm

@@ -1 +0,0 @@
-CCOMMON_OPT += -msimd128 -mrelaxed-simd

Makefile.x86_64

@@ -8,11 +8,6 @@ endif
 endif
 endif
 
-ifeq ($(C_COMPILER), CLANG)
-ifeq ($(findstring icx,$(CC)),icx)
-CCOMMON_OPT += -fp-model=consistent
-endif
-endif
 
 ifneq ($(DYNAMIC_ARCH),1)
 ADD_CPUFLAGS = 1
@@ -61,9 +56,6 @@ endif
 ifeq ($(CORE), SKYLAKEX)
 ifndef NO_AVX512
 CCOMMON_OPT += -march=skylake-avx512
-ifeq ($(C_COMPILER), CLANG)
-CCOMMON_OPT += -mllvm -exhaustive-register-search
-endif
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=skylake-avx512
 endif
@@ -83,32 +75,18 @@ endif
 ifeq ($(CORE), COOPERLAKE)
 ifndef NO_AVX512
 ifeq ($(C_COMPILER), GCC)
- # cooperlake support was added in 10.1
- ifeq ($(GCCVERSIONGTEQ10)$(GCCMINORVERSIONGTEQ1), 11)
-  CCOMMON_OPT += -march=cooperlake
-  ifneq ($(F_COMPILER), NAG)
-   FCOMMON_OPT += -march=cooperlake
-  endif
- else  # gcc not support, fallback to avx512
-  CCOMMON_OPT += -march=skylake-avx512
-  ifneq ($(F_COMPILER), NAG)
-   FCOMMON_OPT += -march=skylake-avx512
-  endif
- endif
-else ifeq ($(C_COMPILER), CLANG)
- CCOMMON_OPT += -mllvm -exhaustive-register-search
- # cooperlake support was added in clang 9
- ifeq ($(CLANGVERSIONGTEQ9), 1)
-  CCOMMON_OPT += -march=cooperlake
-  ifneq ($(F_COMPILER), NAG)
-   FCOMMON_OPT += -march=cooperlake
-  endif
- else  # not supported in clang, fallback to avx512
-  CCOMMON_OPT += -march=skylake-avx512
-  ifneq ($(F_COMPILER), NAG)
-   FCOMMON_OPT += -march=skylake-avx512
-  endif
- endif
+# cooperlake support was added in 10.1
+ifeq ($(GCCVERSIONGTEQ10)$(GCCMINORVERSIONGTEQ1), 11)
+CCOMMON_OPT += -march=cooperlake
+ifneq ($(F_COMPILER), NAG)
+FCOMMON_OPT += -march=cooperlake
+endif
+else  # gcc not support, fallback to avx512
+CCOMMON_OPT += -march=skylake-avx512
+ifneq ($(F_COMPILER), NAG)
+FCOMMON_OPT += -march=skylake-avx512
+endif
+endif
 endif
 ifeq ($(OSNAME), CYGWIN_NT)
 CCOMMON_OPT += -fno-asynchronous-unwind-tables
@@ -126,53 +104,19 @@ endif
 ifeq ($(CORE), SAPPHIRERAPIDS)
 ifndef NO_AVX512
 ifeq ($(C_COMPILER), GCC)
- # sapphire rapids support was added in 11
- ifeq ($(GCCVERSIONGTEQ11), 1)
-  CCOMMON_OPT += -march=sapphirerapids
-  ifneq ($(F_COMPILER), NAG)
-   FCOMMON_OPT += -march=sapphirerapids
-  endif
- else  # gcc not support, fallback to avx512
-  CCOMMON_OPT += -march=skylake-avx512
-  ifneq ($(F_COMPILER), NAG)
-   FCOMMON_OPT += -march=skylake-avx512
-  endif
- endif
-else ifeq ($(C_COMPILER), CLANG)
-  CCOMMON_OPT += -mllvm -exhaustive-register-search
- # sapphire rapids support was added in clang 12
- ifeq ($(CLANGVERSIONGTEQ12), 1)
-  CCOMMON_OPT += -march=sapphirerapids
-  ifneq ($(F_COMPILER), NAG)
-   FCOMMON_OPT += -march=sapphirerapids
-  endif
- else  # not supported in clang, fallback to avx512
-  CCOMMON_OPT += -march=skylake-avx512
-  ifneq ($(F_COMPILER), NAG)
-   FCOMMON_OPT += -march=skylake-avx512
-  endif
- endif
+# sapphire rapids support was added in 11
+ifeq ($(GCCVERSIONGTEQ11), 1)
+CCOMMON_OPT += -march=sapphirerapids
+ifneq ($(F_COMPILER), NAG)
+FCOMMON_OPT += -march=sapphirerapids
 endif
-ifeq ($(OSNAME), CYGWIN_NT)
-CCOMMON_OPT += -fno-asynchronous-unwind-tables
-FCOMMON_OPT += -fno-asynchronous-unwind-tables
-endif
-ifeq ($(OSNAME), WINNT)
-ifeq ($(C_COMPILER), GCC)
-CCOMMON_OPT += -fno-asynchronous-unwind-tables
-FCOMMON_OPT += -fno-asynchronous-unwind-tables
-endif
-endif
-endif
-endif
-
-ifeq ($(CORE), ZEN)
-ifdef HAVE_AVX512VL	
-ifndef NO_AVX512
+else  # gcc not support, fallback to avx512
 CCOMMON_OPT += -march=skylake-avx512
 ifneq ($(F_COMPILER), NAG)
 FCOMMON_OPT += -march=skylake-avx512
 endif
+endif
+endif
 ifeq ($(OSNAME), CYGWIN_NT)
 CCOMMON_OPT += -fno-asynchronous-unwind-tables
 FCOMMON_OPT += -fno-asynchronous-unwind-tables
@@ -185,8 +129,6 @@ endif
 endif
 endif
 endif
-endif
-
 
 ifdef HAVE_AVX2
 ifndef NO_AVX2
@@ -201,7 +143,6 @@ ifeq ($(C_COMPILER), CLANG)
 CCOMMON_OPT += -mavx2
 endif
 endif
-ifeq ($(NOFORTRAN), $(filter 0,$(NOFORTRAN)))
 ifeq ($(F_COMPILER), GFORTRAN)
 # AVX2 support was added in 4.7.0
 GCCVERSIONGTEQ4 := $(shell expr `$(FC) -dumpversion | cut -f1 -d.` \>= 4)
@@ -218,7 +159,6 @@ endif
 endif
 endif
 endif
-endif
 
 endif
 

README.md

@@ -2,93 +2,79 @@
 
 [![Join the chat at https://gitter.im/xianyi/OpenBLAS](https://badges.gitter.im/Join%20Chat.svg)](https://gitter.im/xianyi/OpenBLAS?utm_source=badge&utm_medium=badge&utm_campaign=pr-badge&utm_content=badge)
 
-GitHub Actions: [![Build Status](https://github.com/OpenMathLib/OpenBLAS/actions/workflows/dynamic_arch.yml/badge.svg?branch=develop)](https://github.com/OpenMathLib/OpenBLAS/actions/workflows/dynamic_arch.yml?query=branch%3Adevelop)
+Travis CI: [![Build Status](https://travis-ci.com/xianyi/OpenBLAS.svg?branch=develop)](https://travis-ci.com/xianyi/OpenBLAS)
+
+AppVeyor: [![Build status](https://ci.appveyor.com/api/projects/status/09sohd35n8nkkx64/branch/develop?svg=true)](https://ci.appveyor.com/project/xianyi/openblas/branch/develop)
+
+Drone CI: [![Build Status](https://cloud.drone.io/api/badges/xianyi/OpenBLAS/status.svg?branch=develop)](https://cloud.drone.io/xianyi/OpenBLAS/)
+
+[![Build Status](https://dev.azure.com/xianyi/OpenBLAS/_apis/build/status/xianyi.OpenBLAS?branchName=develop)](https://dev.azure.com/xianyi/OpenBLAS/_build/latest?definitionId=1&branchName=develop)
 
-Azure Pipelines: [![Build Status](https://dev.azure.com/xianyi/OpenBLAS/_apis/build/status/xianyi.OpenBLAS?branchName=develop)](https://dev.azure.com/xianyi/OpenBLAS/_build/latest?definitionId=1&branchName=develop)
 
 ## Introduction
 
 OpenBLAS is an optimized BLAS (Basic Linear Algebra Subprograms) library based on GotoBLAS2 1.13 BSD version.
 
-For more information about OpenBLAS, please see:
-
-- The documentation at [openmathlib.org/OpenBLAS/docs/](http://www.openmathlib.org/OpenBLAS/docs),
-- The home page at [openmathlib.org/OpenBLAS/](http://www.openmathlib.org/OpenBLAS).
+Please read the documentation on the OpenBLAS wiki pages: <https://github.com/xianyi/OpenBLAS/wiki>.
 
 For a general introduction to the BLAS routines, please refer to the extensive documentation of their reference implementation hosted at netlib:
 <https://www.netlib.org/blas>. On that site you will likewise find documentation for the reference implementation of the higher-level library LAPACK - the **L**inear **A**lgebra **Pack**age that comes included with OpenBLAS. If you are looking for a general primer or refresher on Linear Algebra, the set of six
-20-minute lecture videos by Prof. Gilbert Strang on either MIT OpenCourseWare [here](https://ocw.mit.edu/resources/res-18-010-a-2020-vision-of-linear-algebra-spring-2020/) or YouTube [here](https://www.youtube.com/playlist?list=PLUl4u3cNGP61iQEFiWLE21EJCxwmWvvek) may be helpful.
+20-minute lecture videos by Prof. Gilbert Strang on either MIT OpenCourseWare <https://ocw.mit.edu/resources/res-18-010-a-2020-vision-of-linear-algebra-spring-2020/> or Youtube <https://www.youtube.com/playlist?list=PLUl4u3cNGP61iQEFiWLE21EJCxwmWvvek> may be helpful.
 
 ## Binary Packages
 
 We provide official binary packages for the following platform:
 
   * Windows x86/x86_64
-  * Windows arm64 (woa)
 
-You can download them from [file hosting on sourceforge.net](https://sourceforge.net/projects/openblas/files/) or from the [Releases section of the GitHub project page](https://github.com/OpenMathLib/OpenBLAS/releases).
-
-OpenBLAS is also packaged for many package managers - see [the installation section of the docs](http://www.openmathlib.org/OpenBLAS/docs/install/) for details.
+You can download them from [file hosting on sourceforge.net](https://sourceforge.net/projects/openblas/files/) or from the Releases section of the github project page, [https://github.com/xianyi/OpenBLAS/releases](https://github.com/xianyi/OpenBLAS/releases).
 
 ## Installation from Source
 
-Obtain the source code from https://github.com/OpenMathLib/OpenBLAS/. Note that the default branch
-is `develop` (a `master` branch is still present, but far out of date).
-
-Build-time parameters can be chosen in `Makefile.rule`, see there for a short description of each option.
-Most options can also be given directly on the command line as parameters to your `make` or `cmake` invocation.
+Download from project homepage, https://xianyi.github.com/OpenBLAS/, or check out the code
+using Git from https://github.com/xianyi/OpenBLAS.git. (If you want the most up to date version, be
+sure to use the develop branch - master is several years out of date due to a change of maintainership.)
+Buildtime parameters can be chosen in Makefile.rule, see there for a short description of each option.
+Most can also be given directly on the make or cmake command line.
 
 ### Dependencies
 
 Building OpenBLAS requires the following to be installed:
 
-* GNU Make or CMake
-* A C compiler, e.g. GCC or Clang 
+* GNU Make
+* A C compiler, e.g. GCC or Clang
 * A Fortran compiler (optional, for LAPACK)
-
-In general, using a recent version of the compiler is strongly recommended.
-If a Fortran compiler is not available, it is possible to compile an older version of the included LAPACK
-that has been machine-translated to C.
+* IBM MASS (optional, see below)
 
 ### Normal compile
 
 Simply invoking `make` (or `gmake` on BSD) will detect the CPU automatically.
 To set a specific target CPU, use `make TARGET=xxx`, e.g. `make TARGET=NEHALEM`.
-The full target list is in the file `TargetList.txt`, other build optionss are documented in Makefile.rule and
-can either be set there (typically by removing the comment character from the respective line), or used on the
-`make` command line. 
-Note that when you run `make install` after building, you need to repeat all command line options you provided to `make`
-in the build step, as some settings like the supported maximum number of threads are automatically derived from the
-build host by default, which might not be what you want.
-For building with `cmake`, the usual conventions apply, i.e. create a build directory either underneath the toplevel
-OpenBLAS source directory or separate from it, and invoke `cmake` there with the path to the source tree and any 
-build options you plan to set.
-
-For more details, see the [Building from source](http://www.openmathlib.org/OpenBLAS/docs/install/#building-from-source)
-section in the docs.
+The full target list is in the file `TargetList.txt`. For building with `cmake`, the
+usual conventions apply, i.e. create a build directory either underneath the toplevel
+OpenBLAS source directory or separate from it, and invoke `cmake` there with the path
+to the source tree and any build options you plan to set.
 
 ### Cross compile
 
-Set `CC` and `FC` to point to the cross toolchains, and if you use `make`, also set `HOSTCC` to your host C compiler.
+Set `CC` and `FC` to point to the cross toolchains, and set `HOSTCC` to your host C compiler.
 The target must be specified explicitly when cross compiling.
 
 Examples:
 
-* On a Linux system, cross-compiling to an older MIPS64 router board:
+* On an x86 box, compile this library for a loongson3a CPU:
   ```sh
-  make BINARY=64 CC=mipsisa64r6el-linux-gnuabi64-gcc FC=mipsisa64r6el-linux-gnuabi64-gfortran HOSTCC=gcc TARGET=P6600
+  make BINARY=64 CC=mips64el-unknown-linux-gnu-gcc FC=mips64el-unknown-linux-gnu-gfortran HOSTCC=gcc TARGET=LOONGSON3A
   ```
-*  or to a Windows x64 host: 
+  or same with the newer mips-crosscompiler put out by Loongson that defaults to the 32bit ABI:
   ```sh
-  make CC="i686-w64-mingw32-gcc -Bstatic" FC="i686-w64-mingw32-gfortran -static-libgfortran" TARGET=HASWELL BINARY=32 CROSS=1 NUM_THREADS=20 CONSISTENT_FPCSR=1 HOSTCC=gcc
+  make HOSTCC=gcc CC='/opt/mips-loongson-gcc7.3-linux-gnu/2019.06-29/bin/mips-linux-gnu-gcc -mabi=64' FC='/opt/mips-loongson-gcc7.3-linux-gnu/2019.06-29/bin/mips-linux-gnu-gfortran -mabi=64' TARGET=LOONGSON3A
   ```
 
-You can find instructions for other cases both in the "Supported Systems" section below and in
-the [Building from source docs](http://www.openmathlib.org/OpenBLAS/docs/install).
-The `.yml` scripts included with the sources (which contain the
-build scripts for the "continuous integration" (CI) build tests automatically run on every proposed change to the sources) may also provide additional hints.
-
-When compiling for a more modern CPU target of the same architecture, e.g. `TARGET=SKYLAKEX` on a `HASWELL` host, option `CROSS=1` can be used to suppress the automatic invocation of the tests at the end of the build.
+* On an x86 box, compile this library for a loongson3a CPU with loongcc (based on Open64) compiler:
+  ```sh
+  make CC=loongcc FC=loongf95 HOSTCC=gcc TARGET=LOONGSON3A CROSS=1 CROSS_SUFFIX=mips64el-st-linux-gnu-   NO_LAPACKE=1 NO_SHARED=1 BINARY=32
+  ```
 
 ### Debug version
 
@@ -127,7 +113,7 @@ Use `PREFIX=` when invoking `make`, for example
 ```sh
 make install PREFIX=your_installation_directory
 ```
-(along with all options you added on the `make` command line in the preceding build step)
+
 The default installation directory is `/opt/OpenBLAS`.
 
 ## Supported CPUs and Operating Systems
@@ -143,12 +129,11 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
 - **Intel Haswell**: Optimized Level-3 and Level-2 BLAS with AVX2 and FMA on x86-64.
 - **Intel Skylake-X**: Optimized Level-3 and Level-2 BLAS with AVX512 and FMA on x86-64.
 - **Intel Cooper Lake**: as Skylake-X with improved BFLOAT16 support.
-- **Intel Sapphire Rapids**: as Cooper Lake with improved BFLOAT16 SBGEMM kernel.
 - **AMD Bobcat**: Used GotoBLAS2 Barcelona codes.
 - **AMD Bulldozer**: x86-64 ?GEMM FMA4 kernels. (Thanks to Werner Saar)
 - **AMD PILEDRIVER**: Uses Bulldozer codes with some optimizations.
 - **AMD STEAMROLLER**: Uses Bulldozer codes with some optimizations.
-- **AMD ZEN**: Uses Haswell codes with some optimizations for Zen 2/3, SkylakeX for Zen4, Cooperlake for Zen5
+- **AMD ZEN**: Uses Haswell codes with some optimizations.
 
 #### MIPS32
 
@@ -171,9 +156,8 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
 - **Cortex-A53**: same as ARMV8 (different cpu specifications)
 - **Cortex-A55**: same as ARMV8 (different cpu specifications)
 - **Cortex A57**: Optimized Level-3 and Level-2 functions
-- **Cortex A72**: same as A57 (different cpu specifications)
+- **Cortex A72**: same as A57 ( different cpu specifications)
 - **Cortex A73**: same as A57 (different cpu specifications)
-- **Cortex A76**: same as A57 (different cpu specifications)
 - **Falkor**: same as A57 (different cpu specifications)
 - **ThunderX**: Optimized some Level-1 functions
 - **ThunderX2T99**: Optimized Level-3 BLAS and parts of Levels 1 and 2
@@ -181,27 +165,13 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
 - **TSV110**: Optimized some Level-3 helper functions
 - **EMAG 8180**: preliminary support based on A57
 - **Neoverse N1**: (AWS Graviton2) preliminary support
-- **Neoverse V1**: (AWS Graviton3) optimized Level-3 BLAS
-- **Neoverse N2**: preliminary support
-- **Neoverse V2**: preliminary support
-- **Neoverse V3**: preliminary support
-- **Neoverse V3AE**: preliminary support
-- **Apple Vortex**: preliminary support based on ThunderX2/3
-- **Apple VortexM4**: preliminary support based on ThunderX2/3, SME kernels for SGEMM,SSYMM,STRMM,SSYRK,SSYR2K
-- **A64FX**:  preliminary support, optimized Level-3 BLAS
-- **ARMV8SVE**: any ARMV8 cpu with SVE extensions 
-- **ARMV9SME**: any ARMV9 cpu with SVE and SME extensions 
+- **Apple Vortex**: preliminary support based on ARMV8
 
 #### PPC/PPC64
 
 - **POWER8**: Optimized BLAS, only for PPC64LE (Little Endian), only with `USE_OPENMP=1`
 - **POWER9**: Optimized Level-3 BLAS (real) and some Level-1,2. PPC64LE with OpenMP only. 
-- **POWER10**: Optimized Level-3 BLAS including SBGEMM and some Level-1,2.
-
-- **AIX**: Dynamic architecture with OpenXL and OpenMP.
-  ```sh
-  make CC=ibm-clang_r FC=xlf_r TARGET=POWER7 BINARY=64 USE_OPENMP=1 INTERFACE64=1 DYNAMIC_ARCH=1 USE_THREAD=1
-  ```
+- **POWER10**:
 
 #### IBM zEnterprise System
 
@@ -214,102 +184,45 @@ Please read `GotoBLAS_01Readme.txt` for older CPU models already supported by th
   ```sh
   make HOSTCC=gcc TARGET=C910V CC=riscv64-unknown-linux-gnu-gcc FC=riscv64-unknown-linux-gnu-gfortran
   ```
-  (also known to work on C906 as long as you use only single-precision functions - its instruction set support appears to be incomplete in double precision)
-
-- **x280**: Level-3 BLAS and Level-1,2 are optimized by RISC-V Vector extension 1.0.
-  ```sh
-  make HOSTCC=gcc TARGET=x280 NUM_THREADS=8 CC=riscv64-unknown-linux-gnu-clang FC=riscv64-unknown-linux-gnu-gfortran
-  ```
-
-(For RVV 1.0 target selection and compiler requirements, see the [RISC-V section in docs/install.md](docs/install.md#risc-v).)
-
-- **ZVL???B**: Level-3 BLAS and Level-1,2 including vectorised kernels targeting generic RISCV cores with vector support with registers of at least the corresponding width; ZVL128B and ZVL256B are available.
-e.g.:
-  ```sh
-    make TARGET=RISCV64_ZVL256B CFLAGS="-DTARGET=RISCV64_ZVL256B" \
-    BINARY=64 ARCH=riscv64 CC='clang -target riscv64-unknown-linux-gnu' \
-    AR=riscv64-unknown-linux-gnu-ar AS=riscv64-unknown-linux-gnu-gcc \
-    LD=riscv64-unknown-linux-gnu-gcc FC=riscv64-unknown-linux-gnu-gfortran \
-    HOSTCC=gcc HOSTFC=gfortran -j
-  ```
-
-#### LOONGARCH64
-
-- **LA64_GENERIC**: Optimized Level-3, Level-2 and Level-1 BLAS with scalar instruction
-  ```sh
-  make HOSTCC=gcc TARGET=LA64_GENERIC CC=loongarch64-unknown-linux-gnu-gcc FC=loongarch64-unknown-linux-gnu-gfortran USE_SIMPLE_THREADED_LEVEL3=1
-  ```
-  The old-style TARGET=LOONGSONGENERIC is still supported
-
-- **LA264**: Optimized Level-3, Level-2 and Level-1 BLAS with LSX instruction
-  ```sh
-  make HOSTCC=gcc TARGET=LA264 CC=loongarch64-unknown-linux-gnu-gcc FC=loongarch64-unknown-linux-gnu-gfortran USE_SIMPLE_THREADED_LEVEL3=1
-  ```
-  The old-style TARGET=LOONGSON2K1000 is still supported
-
-- **LA464**: Optimized Level-3, Level-2 and Level-1 BLAS with LASX instruction
-  ```sh
-  make HOSTCC=gcc TARGET=LA464 CC=loongarch64-unknown-linux-gnu-gcc FC=loongarch64-unknown-linux-gnu-gfortran USE_SIMPLE_THREADED_LEVEL3=1
-  ```
-  The old-style TARGET=LOONGSON3R5 is still supported
-
-#### WASM
-  Not a cpu target in the strict sense, but portable WebAssembly for browser-based applications and the like. See emscripten.org for the compiler and related information
-
-- **WASM128_GENERIC**: Optimized SGEMM,DGEMM, DAXPY, SSUM/DSUM, SDOT/DDOT and SROT/DROT
-
+  (also known to work on C906)
 
 ### Support for multiple targets in a single library
 
-OpenBLAS can be built for multiple targets with runtime detection of the target cpu by specifying `DYNAMIC_ARCH=1` in Makefile.rule, on the gmake command line or as `-DDYNAMIC_ARCH=TRUE` in cmake.
+OpenBLAS can be built for multiple targets with runtime detection of the target cpu by specifiying `DYNAMIC_ARCH=1` in Makefile.rule, on the gmake command line or as `-DDYNAMIC_ARCH=TRUE` in cmake.
 
-For **x86_64**, the list of targets this activates contains Prescott, Core2, Nehalem, Barcelona, Sandybridge, Bulldozer, Piledriver, Steamroller, Excavator, Haswell, Zen, SkylakeX, Cooper Lake, Sapphire Rapids. For cpu generations not included in this list, the corresponding older model is used. If you also specify `DYNAMIC_OLDER=1`, specific support for Penryn, Dunnington, Opteron, Opteron/SSE3, Bobcat, Atom and Nano is added. Finally there is an option `DYNAMIC_LIST` that allows to specify an individual list of targets to include instead of the default.
+For **x86_64**, the list of targets this activates contains Prescott, Core2, Nehalem, Barcelona, Sandybridge, Bulldozer, Piledriver, Steamroller, Excavator, Haswell, Zen, SkylakeX. For cpu generations not included in this list, the corresponding older model is used. If you also specify `DYNAMIC_OLDER=1`, specific support for Penryn, Dunnington, Opteron, Opteron/SSE3, Bobcat, Atom and Nano is added. Finally there is an option `DYNAMIC_LIST` that allows to specify an individual list of targets to include instead of the default.
 
 `DYNAMIC_ARCH` is also supported on **x86**, where it translates to Katmai, Coppermine, Northwood, Prescott, Banias,
 Core2, Penryn, Dunnington, Nehalem, Athlon, Opteron, Opteron_SSE3, Barcelona, Bobcat, Atom and Nano.
 
-On **ARMV8**, it enables support for CortexA53, CortexA57, CortexA72, CortexA73, Falkor, ThunderX, ThunderX2T99, TSV110 as well as generic ARMV8 cpus. If compiler support for SVE is available at build time, support for NeoverseN2, NeoverseV1 as well as generic ArmV8SVE targets is also enabled.
+On **ARMV8**, it enables support for CortexA53, CortexA57, CortexA72, CortexA73, Falkor, ThunderX, ThunderX2T99, TSV110 as well as generic ARMV8 cpus.
 
-For **POWER**, the list encompasses POWER6, POWER8 and POWER9. POWER10 is additionally available if a sufficiently recent compiler is used for the build.
-
-on **ZARCH** it comprises Z13 and Z14 as well as generic zarch support.
-
-On **riscv64**, DYNAMIC_ARCH enables support for riscv64_zvl128b and riscv64_zvl256b in addition to generic riscv64 support.  A compiler that supports RVV 1.0 is required to build OpenBLAS for riscv64 when DYNAMIC_ARCH is enabled.
-
-On **LoongArch64**, it comprises LA264 and LA464 as well as generic LoongArch64 support.
-
-The `TARGET` option can - and usually **should** - be used in conjunction with `DYNAMIC_ARCH=1` to specify which cpu model should be assumed for all the common code in the library, usually you will want to set this to the oldest model you expect to encounter.
-Failure to specify this may lead to advanced instructions being used by the compiler, just because the build host happens to support them. This is most likely to happen when aggressive optimization options are in effect, and the resulting library may then crash with an
-illegal instruction error on weaker hardware, before it even reaches the BLAS routines specifically included for that cpu.
+For **POWER**, the list encompasses POWER6, POWER8 and POWER9, on **ZARCH** it comprises Z13 and Z14.
 
+The `TARGET` option can be used in conjunction with `DYNAMIC_ARCH=1` to specify which cpu model should be assumed for all the
+common code in the library, usually you will want to set this to the oldest model you expect to encounter.
 Please note that it is not possible to combine support for different architectures, so no combined 32 and 64 bit or x86_64 and arm64 in the same library.
 
 ### Supported OS
 
 - **GNU/Linux**
-- **MinGW or Visual Studio (CMake)/Windows**: Please read <https://github.com/OpenMathLib/OpenBLAS/blob/develop/docs/install.md#visual-studio--native-windows-abi>.
-- **Darwin/macOS/OSX/iOS**: Already supported on PPC and x86 by the original GotoBLAS, now also on ARM64 but we are not OSX/iOS experts.
-- **FreeBSD**: Supported by the community. Basic test coverage is provided by GitHub Actions.
+- **MinGW or Visual Studio (CMake)/Windows**: Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-use-OpenBLAS-in-Microsoft-Visual-Studio>.
+- **Darwin/macOS/OSX/iOS**: Experimental. Although GotoBLAS2 already supports Darwin, we are not OSX/iOS experts.
+- **FreeBSD**: Supported by the community. We don't actively test the library on this OS.
 - **OpenBSD**: Supported by the community. We don't actively test the library on this OS.
 - **NetBSD**: Supported by the community. We don't actively test the library on this OS.
 - **DragonFly BSD**: Supported by the community. We don't actively test the library on this OS.
-- **Android**: Supported by the community. Please read <https://github.com/OpenMathLib/OpenBLAS/blob/develop/docs/install.md#android>.
-- **AIX**: Supported on PPC up to POWER10 but testing is increasingly problematic due to lack of publicly available systems
+- **Android**: Supported by the community. Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-build-OpenBLAS-for-Android>.
+- **AIX**: Supported on PPC up to POWER8
 - **Haiku**: Supported by the community. We don't actively test the library on this OS.
 - **SunOS**: Supported by the community. We don't actively test the library on this OS.
-- **Cortex-M**: Supported by the community. Please read <https://github.com/OpenMathLib/OpenBLAS/blob/develop/docs/install.md#cortex-m>.
+- **Cortex-M**: Supported by the community. Please read <https://github.com/xianyi/OpenBLAS/wiki/How-to-use-OpenBLAS-on-Cortex-M>.
 
 ## Usage
 
 Statically link with `libopenblas.a` or dynamically link with `-lopenblas` if OpenBLAS was
 compiled as a shared library.
 
-### Considerations for using the library from Java
-
-The default stack size of only 1MB may be too small, especially if you built OpenBLAS to support larger matrix sizes than provided for by the default settings. Use the -Xss option to request a larger stack size if you encounter problems.
-
-When a Windows build of OpenBLAS was created using the MINGW gfortran (for the LAPACK parts), the java application may hang on startup due to a deadlock between the gfortran runtime library initialization and any pipes created by a Win11/SBT/Play Framework environment. Use -Djdk.console=jdk.internal.le to work around this. 
-
 ### Setting the number of threads using environment variables
 
 Environment variables are used to specify a maximum number of threads.
@@ -341,28 +254,24 @@ If you compile this library with `USE_OPENMP=1`, you should use the above functi
 
 ## Reporting bugs
 
-Please submit an issue in https://github.com/OpenMathLib/OpenBLAS/issues.
+Please submit an issue in https://github.com/xianyi/OpenBLAS/issues.
 
 ## Contact
 
-+ Use github discussions: https://github.com/OpenMathLib/OpenBLAS/discussions
 * OpenBLAS users mailing list: https://groups.google.com/forum/#!forum/openblas-users
 * OpenBLAS developers mailing list: https://groups.google.com/forum/#!forum/openblas-dev
 
 ## Change log
 
-Please see Changelog.txt.
+Please see Changelog.txt to view the differences between OpenBLAS and GotoBLAS2 1.13 BSD version.
 
 ## Troubleshooting
 
-* Please read the [FAQ](http://www.openmathlib.org/OpenBLAS/docs/faq) section of the docs first.
+* Please read the [FAQ](https://github.com/xianyi/OpenBLAS/wiki/Faq) first.
 * Please use GCC version 4.6 and above to compile Sandy Bridge AVX kernels on Linux/MinGW/BSD.
 * Please use Clang version 3.1 and above to compile the library on Sandy Bridge microarchitecture.
   Clang 3.0 will generate the wrong AVX binary code.
-* Please use GCC version 6 or LLVM version 6 and above to compile Skylake/CooperLake AVX512 kernels
-* Please use LLVM version 18 and above (version 19 and above on Windows) if you plan to use
-  its new flang compiler for Fortran
-* Please use GCC version 11 and above to compile OpenBLAS on the POWER architecture
+* Please use GCC version 6 or LLVM version 6 and above to compile Skylake AVX512 kernels.
 * The number of CPUs/cores should be less than or equal to 256. On Linux `x86_64` (`amd64`),
   there is experimental support for up to 1024 CPUs/cores and 128 numa nodes if you build
   the library with `BIGNUMA=1`.
@@ -375,12 +284,12 @@ Please see Changelog.txt.
 
 ## Contributing
 
-1. [Check for open issues](https://github.com/OpenMathLib/OpenBLAS/issues) or open a fresh issue
+1. [Check for open issues](https://github.com/xianyi/OpenBLAS/issues) or open a fresh issue
    to start a discussion around a feature idea or a bug.
-2. Fork the [OpenBLAS](https://github.com/OpenMathLib/OpenBLAS) repository to start making your changes.
+2. Fork the [OpenBLAS](https://github.com/xianyi/OpenBLAS) repository to start making your changes.
 3. Write a test which shows that the bug was fixed or that the feature works as expected.
 4. Send a pull request. Make sure to add yourself to `CONTRIBUTORS.md`.
 
 ## Donation
 
-Please see [the donations section](http://www.openmathlib.org/OpenBLAS/docs/about/#donations) in the docs.
+Please read [this wiki page](https://github.com/xianyi/OpenBLAS/wiki/Donation).

SECURITY.md

@@ -1,20 +0,0 @@
-# Security Policy
-
-## Supported Versions
-
-It is generally recommended to use the latest release as this project
-does not maintain multiple stable branches and providing packages e.g.
-for Linux distributions is outside our scope. In particular, versions
-before 0.3.18 can be assumed to carry the out-of-bounds-read error in
-the LAPACK ?LARRV family of functions that was the subject of 
-CVE-2021-4048
-
-## Reporting a Vulnerability
-
-If you suspect that you have found a vulnerability - a defect that could
-be abused to compromise the security of a user's code or systems - please
-do not use the normal github issue tracker (except perhaps to post a general
-warning if you deem that necessary). Instead, please contact the project 
-maintainers through the email addresses given in their github user profiles.
-Defects found in the "lapack-netlib" subtree should ideally be reported to
-the maintainers of the reference implementation of LAPACK, lapack@icl.itk.edu

TargetList.txt

@@ -52,7 +52,6 @@ POWER7
 POWER8
 POWER9
 POWER10
-POWER11
 PPCG4
 PPC970
 PPC970MP
@@ -66,7 +65,6 @@ MIPS1004K
 MIPS24K
 
 4.MIPS64 CPU:
-MIPS64_GENERIC
 SICORTEX
 LOONGSON3A
 LOONGSON3B
@@ -94,15 +92,9 @@ CORTEXA53
 CORTEXA57
 CORTEXA72
 CORTEXA73
-CORTEXA76
-CORTEXA510
-CORTEXA710
-CORTEXX1
-CORTEXX2
 NEOVERSEN1
 NEOVERSEV1
 NEOVERSEN2
-NEOVERSEV2
 CORTEXA55
 EMAG8180
 FALKOR
@@ -111,11 +103,6 @@ THUNDERX2T99
 TSV110
 THUNDERX3T110
 VORTEX
-VORTEXM4
-A64FX
-ARMV8SVE
-ARMV9SME
-FT2000
 
 9.System Z:
 ZARCH_GENERIC
@@ -123,38 +110,8 @@ Z13
 Z14
 
 10.RISC-V 64:
-RISCV64_GENERIC (e.g. PolarFire Soc/SiFive U54)
-RISCV64_ZVL128B
+RISCV64_GENERIC
 C910V
-x280
-RISCV64_ZVL256B
-U74 (e.g. SiFive U74 / StarFive JH7110 / VisionFive 2)
 
 11.LOONGARCH64:
-// LOONGSONGENERIC/LOONGSON2K1000/LOONGSON3R5 are legacy names,
-// and it is recommended to use the more standardized naming conventions
-// LA64_GENERIC/LA264/LA464. You can still specify TARGET as
-// LOONGSONGENERIC/LOONGSON2K1000/LOONGSON3R5 during compilation or runtime,
-// and they will be internally relocated to LA64_GENERIC/LA264/LA464.
-LOONGSONGENERIC
-LOONGSON2K1000
 LOONGSON3R5
-LA64_GENERIC
-LA264
-LA464
-
-12. Elbrus E2000:
-E2K
-
-13. Alpha
-EV4
-EV5
-EV6
-
-14.CSKY
-CSKY
-CK860FV
-
-15. WebAssembly/Emscripten:
-WASM128_GENERIC
-

azure-pipelines.yml

@@ -4,15 +4,6 @@ trigger:
   branches:
     include:
       - develop
-  paths:
-    exclude:
-      - 'docs/**'
-      - '**/*.md'
-pr:
-  paths:
-    exclude:
-      - 'docs/**'
-      - '**/*.md'
 resources:
   containers:
       - container: oneapi-hpckit
@@ -34,28 +25,14 @@ jobs:
       echo "FROM quay.io/pypa/manylinux1_x86_64
         COPY . /tmp/openblas
         RUN cd /tmp/openblas                                      &&  \
-            CC=gcc && \
-            make QUIET_MAKE=1 BINARY=64 DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32 && \
-            make -C test BINARY=64 DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32 && \
-            make -C ctest BINARY=64 DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32 && \
-            make -C utest BINARY=64 DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32" > Dockerfile
+            COMMON_FLAGS='DYNAMIC_ARCH=1 TARGET=NEHALEM NUM_THREADS=32' && \
+            BTYPE='BINARY=64' CC=gcc && \
+            make QUIET_MAKE=1 $COMMON_FLAGS $BTYPE && \
+            make -C test $COMMON_FLAGS $BTYPE && \
+            make -C ctest $COMMON_FLAGS $BTYPE && \
+            make -C utest $COMMON_FLAGS $BTYPE" > Dockerfile
       docker build .
     displayName: Run manylinux1 docker build
-- job: manylinux_32bit
-  pool:
-    vmImage: 'ubuntu-latest'
-  steps:
-  - script: |
-      echo "FROM quay.io/pypa/manylinux2014_i686
-        COPY . /tmp/openblas
-        RUN cd /tmp/openblas                                      &&  \
-            CC=gcc && \
-            make QUIET_MAKE=1 BINARY=32 TARGET=NEHALEM NUM_THREADS=32 && \
-            make -C test BINARY=32 TARGET=NEHALEM NUM_THREADS=32 && \
-            make -C ctest BINARY=32 TARGET=NEHALEM NUM_THREADS=32 && \
-            make -C utest BINARY=32 TARGET=NEHALEM NUM_THREADS=32" > Dockerfile
-      docker build .
-    displayName: Run manylinux 32bit docker build
 - job: Intel_SDE_skx
   pool:
     vmImage: 'ubuntu-latest'
@@ -88,7 +65,7 @@ jobs:
   - task: CMake@1
     inputs:
       workingDirectory: 'build' # Optional
-      cmakeArgs: '-G "Visual Studio 17 2022" ..'
+      cmakeArgs: '-G "Visual Studio 16 2019" ..'
   - task: CMake@1
     inputs:
       cmakeArgs: '--build . --config Release'
@@ -100,12 +77,11 @@ jobs:
       openblas_utest.exe
 
 - job: Windows_mingw_gmake
-  timeoutInMinutes: 100
   pool:
      vmImage: 'windows-latest'
   steps:   
   - script: |
-      mingw32-make CC=gcc NOLAPACK=1 DYNAMIC_ARCH=1 DYNAMIC_LIST="SANDYBRIDGE"
+      mingw32-make CC=gcc FC=gfortran DYNAMIC_ARCH=1 DYNAMIC_LIST="NEHALEM SANDYBRIDGE HASWELL"
 
 - job: Windows_clang_cmake
   pool:
@@ -127,7 +103,7 @@ jobs:
 
 - job: Windows_flang_clang
   pool:
-     vmImage: 'windows-2022'
+     vmImage: 'windows-latest'
   steps:
   - script: |
       set "PATH=C:\Miniconda\Scripts;C:\Miniconda\Library\bin;C:\Miniconda\Library\usr\bin;C:\Miniconda\condabin;%PATH%"
@@ -138,127 +114,78 @@ jobs:
       conda install --yes --quiet ninja flang
       mkdir build 
       cd build
-      call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
-      cmake -G "Ninja" -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_Fortran_COMPILER="flang -I C:\Miniconda\Library\include\flang" -DBUILD_TESTING=OFF -DCMAKE_MT=mt -DCMAKE_BUILD_TYPE=Release -DMSVC_STATIC_CRT=ON ..
+      call "C:\Program Files (x86)\Microsoft Visual Studio\2019\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
+      cmake -G "Ninja" -DCMAKE_C_COMPILER=clang-cl -DCMAKE_CXX_COMPILER=clang-cl -DCMAKE_Fortran_COMPILER=flang -DCMAKE_MT=mt -DCMAKE_BUILD_TYPE=Release -DMSVC_STATIC_CRT=ON ..
       cmake --build . --config Release
       ctest
 
-- job: Windows_cl_flang
-  pool:
-     vmImage: 'windows-2022'
-  steps:
-  - script: |
-      set "PATH=C:\Miniconda\Scripts;C:\Miniconda\Library\bin;C:\Miniconda\Library\usr\bin;C:\Miniconda\condabin;%PATH%"
-      set "LIB=C:\Miniconda\Library\lib;%LIB%"
-      set "CPATH=C:\Miniconda\Library\include;%CPATH%"
-      conda config --add channels conda-forge --force
-      conda config --set auto_update_conda false
-      conda install --yes --quiet ninja flang
-      mkdir build 
-      cd build
-      call "C:\Program Files\Microsoft Visual Studio\2022\Enterprise\VC\Auxiliary\Build\vcvars64.bat"
-      cmake -G "Ninja" -DCMAKE_C_COMPILER=cl -DCMAKE_Fortran_COMPILER=flang-new -DC_LAPACK=1 -DCMAKE_MT=mt -DCMAKE_BUILD_TYPE=Release -DMSVC_STATIC_CRT=ON ..
-      cmake --build . --config Release
-      ctest
-      ctest --rerun-failed --output-on-failure
-
-
 - job: OSX_OpenMP
   pool:
-     vmImage: 'macOS-15'
+     vmImage: 'macOS-10.15'
   steps:   
   - script: |
       brew update
-      make TARGET=CORE2 DYNAMIC_ARCH=1 USE_OPENMP=1 INTERFACE64=1 CC=gcc-13 FC=gfortran-13
-      make TARGET=CORE2 DYNAMIC_ARCH=1 USE_OPENMP=1 INTERFACE64=1 CC=gcc-13 FC=gfortran-13 PREFIX=../blasinst install
+      make TARGET=CORE2 DYNAMIC_ARCH=1 USE_OPENMP=1 INTERFACE64=1 CC=gcc-10 FC=gfortran-10
+      make TARGET=CORE2 DYNAMIC_ARCH=1 USE_OPENMP=1 INTERFACE64=1 CC=gcc-10 FC=gfortran-10 PREFIX=../blasinst install
       ls -lR ../blasinst
      
 - job: OSX_GCC_Nothreads
   pool:
-     vmImage: 'macOS-15'
+     vmImage: 'macOS-10.15'
   steps:   
   - script: |
       brew update
-      make USE_THREADS=0 CC=gcc-13 FC=gfortran-13
+      make USE_THREADS=0 CC=gcc-10 FC=gfortran-10
      
-- job: OSX_GCC15
-  pool:
-     vmImage: 'macOS-latest'
-  steps:   
-  - script: |
-      brew update
-      make CC=gcc-15 FC=gfortran-15
-
-- job: OSX_LLVM_flangnew
-  timeoutInMinutes: 100
-  pool:
-     vmImage: 'macOS-latest'
-  variables:
-     LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
-     LIBRARY_PATH: /usr/local/opt/llvm/lib
-     RANLIB: touch
-  steps:   
-  - script: |
-      brew update
-      brew install llvm flang
-      make TARGET=NEHALEM CC=/usr/local/opt/llvm/bin/clang FC=/usr/local/opt/flang/bin/flang NO_SHARED=1
-
 - job: OSX_OpenMP_Clang
-  timeoutInMinutes: 100
   pool:
-     vmImage: 'macOS-latest'
+     vmImage: 'macOS-10.15'
   variables:
      LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
      LIBRARY_PATH: /usr/local/opt/llvm/lib
-     RANLIB: touch
   steps:   
   - script: |
       brew update
       brew install llvm libomp
-      make TARGET=CORE2 USE_OPENMP=1 DYNAMIC_ARCH=1 DYNAMIC_LIST='NEHALEM HASWELL SKYLAKEX' CC=/usr/local/opt/llvm/bin/clang NOFORTRAN=1
+      make TARGET=CORE2 USE_OPENMP=1 INTERFACE64=1 DYNAMIC_ARCH=1 CC=/usr/local/opt/llvm/bin/clang FC=gfortran-10
 
 - job: OSX_OpenMP_Clang_cmake
-  timeoutInMinutes: 100
   pool:
-     vmImage: 'macOS-latest'
+     vmImage: 'macOS-10.15'
   variables:
      LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
      LIBRARY_PATH: /usr/local/opt/llvm/lib
   steps:   
   - script: |
-      set -euo pipefail
       brew update
       brew install llvm libomp
       mkdir build
       cd build
-      cmake -DTARGET=CORE2 -DUSE_OPENMP=1 -DINTERFACE64=1 -DDYNAMIC_ARCH=1 -DDYNAMIC_LIST='NEHALEM;HASWELL;SKYLAKEX' -DCMAKE_C_COMPILER=/usr/local/opt/llvm/bin/clang -DNOFORTRAN=1 -DNO_AVX512=1 ..
-      cmake --build . --parallel "$(sysctl -n hw.logicalcpu)"
+      cmake -DTARGET=CORE2 -DUSE_OPENMP=1 -DINTERFACE64=1 -DDYNAMIC_ARCH=1 -DCMAKE_C_COMPILER=/usr/local/opt/llvm/bin/clang -DNOFORTRAN=1 -DNO_AVX512=1 ..
+      make
       ctest
       
 - job: OSX_dynarch_cmake
-  timeoutInMinutes: 100
   pool:
-     vmImage: 'macOS-15'
+     vmImage: 'macOS-10.15'
   variables:
      LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
      LIBRARY_PATH: /usr/local/opt/llvm/lib
   steps:   
   - script: |
-      set -euo pipefail
       mkdir build
       cd build
-      cmake -DTARGET=CORE2 -DDYNAMIC_ARCH=1 -DDYNAMIC_LIST='NEHALEM;HASWELL;SKYLAKEX' -DCMAKE_C_COMPILER=gcc-13 -DCMAKE_Fortran_COMPILER=gfortran-13 -DBUILD_SHARED_LIBS=ON ..
+      cmake -DTARGET=CORE2 -DDYNAMIC_ARCH=1 -DCMAKE_C_COMPILER=gcc-10 -DCMAKE_Fortran_COMPILER=gfortran-10 -DBUILD_SHARED_LIBS=ON ..
       cmake --build .
       ctest
-
+      
 - job: OSX_Ifort_Clang
   pool:
-     vmImage: 'macOS-latest'
+     vmImage: 'macOS-10.15'
   variables:
      LD_LIBRARY_PATH: /usr/local/opt/llvm/lib
-     MACOS_HPCKIT_URL: https://registrationcenter-download.intel.com/akdlm/IRC_NAS/edb4dc2f-266f-47f2-8d56-21bc7764e119/m_HPCKit_p_2023.2.0.49443.dmg
+     MACOS_HPCKIT_URL: https://registrationcenter-download.intel.com/akdlm/irc_nas/17643/m_HPCKit_p_2021.2.0.2903_offline.dmg
      LIBRARY_PATH: /usr/local/opt/llvm/lib
-     RANLIB: touch
      MACOS_FORTRAN_COMPONENTS: intel.oneapi.mac.ifort-compiler
   steps:   
   - script: |
@@ -287,7 +214,7 @@ jobs:
  
 - job: OSX_NDK_ARMV7
   pool:
-     vmImage: 'macOS-15'
+     vmImage: 'macOS-10.15'
   steps:   
   - script: | 
       brew update
@@ -297,47 +224,32 @@ jobs:
 
 - job: OSX_IOS_ARMV8
   pool:
-     vmImage: 'macOS-15'
+     vmImage: 'macOS-11'
   variables:
-     CC: /Applications/Xcode_16.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-     CFLAGS: -O2 -Wno-macro-redefined -isysroot /Applications/Xcode_16.4.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS18.5.sdk -arch arm64 -miphoneos-version-min=10.0
+     CC: /Applications/Xcode_12.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
+     CFLAGS: -O2 -Wno-macro-redefined -isysroot /Applications/Xcode_12.4.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS14.4.sdk -arch arm64 -miphoneos-version-min=10.0
   steps:
   - script: |
-     ls /Applications/Xcode_16.4.app/Contents/Developer/Platforms/
-     ls /Applications/Xcode_16.4.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs
      make TARGET=ARMV8 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1
 
 - job: OSX_IOS_ARMV7
   pool:
-     vmImage: 'macOS-15'
+     vmImage: 'macOS-10.15'
   variables:
-     CC: /Applications/Xcode_16.2.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-     CFLAGS: -O2 -mno-thumb -Wno-macro-redefined -isysroot /Applications/Xcode_16.2.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS18.2.sdk -arch armv7 -miphoneos-version-min=5.1
+     CC: /Applications/Xcode_12.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
+     CFLAGS: -O2 -mno-thumb -Wno-macro-redefined -isysroot /Applications/Xcode_12.4.app/Contents/Developer/Platforms/iPhoneOS.platform/Developer/SDKs/iPhoneOS14.4.sdk -arch armv7 -miphoneos-version-min=5.1
   steps:
   - script: |
      make TARGET=ARMV7 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1
 
-- job: OSX_xbuild_DYNAMIC_ARM64
-  pool:
-     vmImage: 'macOS-15'
-  variables:
-     CC: /Applications/Xcode_16.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang
-     CFLAGS: -O2 -Wno-macro-redefined -isysroot /Applications/Xcode_16.4.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs/MacOSX15.5.sdk -arch arm64
-  steps:
-  - script: |
-     ls /Applications/Xcode_16.4.app/Contents/Developer/Platforms/MacOSX.platform/Developer/SDKs
-     /Applications/Xcode_16.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang -arch arm64 --print-supported-cpus
-     /Applications/Xcode_16.4.app/Contents/Developer/Toolchains/XcodeDefault.xctoolchain/usr/bin/clang --version
-     make TARGET=ARMV8 DYNAMIC_ARCH=1 NUM_THREADS=32 HOSTCC=clang NOFORTRAN=1
-
 - job: ALPINE_MUSL
   pool:
      vmImage: 'ubuntu-latest'
   steps:
   - script: |
-        wget https://raw.githubusercontent.com/alpinelinux/alpine-chroot-install/v0.14.0/alpine-chroot-install \
-        && echo 'ccbf65f85cdc351851f8ad025bb3e65bae4d5b06  alpine-chroot-install' | sha1sum -c \
-        || exit 1
+        wget https://raw.githubusercontent.com/alpinelinux/alpine-chroot-install/v0.13.2/alpine-chroot-install \
+          && echo '60c7e0b5d82e21d1a549fc9a46ba3b36688c09dc  alpine-chroot-install' | sha1sum -c \
+          || exit 1
         alpine() { /alpine/enter-chroot -u "$USER" "$@"; }
         sudo sh alpine-chroot-install -p 'build-base gfortran perl linux-headers sudo'
         alpine make DYNAMIC_ARCH=1 BINARY=64

benchmark/amax.c

@@ -1,133 +1,133 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef AMAX
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define AMAX BLASFUNC(dzamax)
-#else
-#define AMAX BLASFUNC(scamax)
-#endif
-#else
-#ifdef DOUBLE
-#define AMAX BLASFUNC(damax)
-#else
-#define AMAX BLASFUNC(samax)
-#endif
-#endif
-
-int main(int argc, char *argv[])
-{
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x = 1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from = 1;
-  int to = 200;
-  int step = 1;
-
-  double time1, timeg;
-
-  argc--;
-  argv++;
-
-  if (argc > 0)
-  {
-    from = atol(*argv);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    to = MAX(atol(*argv), from);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    step = atol(*argv);
-    argc--;
-    argv++;
-  }
-
-  if ((p = getenv("OPENBLAS_LOOPS")))
-    loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))
-    inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step, inc_x, loops);
-
-  if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL)
-  {
-    fprintf(stderr, "Out of Memory!!\n");
-    exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for (m = from; m <= to; m += step)
-  {
-
-    timeg = 0;
-    fprintf(stderr, " %6d : ", (int)m);
-
-    for (l = 0; l < loops; l++)
-    {
-
-      for (i = 0; i < m * COMPSIZE * abs(inc_x); i++)
-      {
-        x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
-      }
-
-      begin();
-      AMAX(&m, x, &inc_x);
-      end();
-      timeg += getsec();
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-            " %10.2f MFlops %10.6f sec\n",
-            COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2016, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef AMAX
+
+#ifdef COMPLEX
+#ifdef DOUBLE
+#define AMAX BLASFUNC(dzamax)
+#else
+#define AMAX BLASFUNC(scamax)
+#endif
+#else
+#ifdef DOUBLE
+#define AMAX BLASFUNC(damax)
+#else
+#define AMAX BLASFUNC(samax)
+#endif
+#endif
+
+int main(int argc, char *argv[])
+{
+
+  FLOAT *x;
+  blasint m, i;
+  blasint inc_x = 1;
+  int loops = 1;
+  int l;
+  char *p;
+
+  int from = 1;
+  int to = 200;
+  int step = 1;
+
+  double time1, timeg;
+
+  argc--;
+  argv++;
+
+  if (argc > 0)
+  {
+    from = atol(*argv);
+    argc--;
+    argv++;
+  }
+  if (argc > 0)
+  {
+    to = MAX(atol(*argv), from);
+    argc--;
+    argv++;
+  }
+  if (argc > 0)
+  {
+    step = atol(*argv);
+    argc--;
+    argv++;
+  }
+
+  if ((p = getenv("OPENBLAS_LOOPS")))
+    loops = atoi(p);
+  if ((p = getenv("OPENBLAS_INCX")))
+    inc_x = atoi(p);
+
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step, inc_x, loops);
+
+  if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL)
+  {
+    fprintf(stderr, "Out of Memory!!\n");
+    exit(1);
+  }
+
+#ifdef __linux
+  srandom(getpid());
+#endif
+
+  fprintf(stderr, "   SIZE       Flops\n");
+
+  for (m = from; m <= to; m += step)
+  {
+
+    timeg = 0;
+    fprintf(stderr, " %6d : ", (int)m);
+
+    for (l = 0; l < loops; l++)
+    {
+
+      for (i = 0; i < m * COMPSIZE * abs(inc_x); i++)
+      {
+        x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
+      }
+
+      begin();
+      AMAX(&m, x, &inc_x);
+      end();
+      timeg += getsec();
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr,
+            " %10.2f MFlops %10.6f sec\n",
+            COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
+  }
+
+  return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/amin.c

@@ -1,137 +1,137 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef AMIN
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define AMIN BLASFUNC(dzamin)
-#else
-#define AMIN BLASFUNC(scamin)
-#endif
-#else
-#ifdef DOUBLE
-#define AMIN BLASFUNC(damin)
-#else
-#define AMIN BLASFUNC(samin)
-#endif
-#endif
-
-int main(int argc, char *argv[])
-{
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x = 1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from = 1;
-  int to = 200;
-  int step = 1;
-
-  double time1, timeg;
-
-  argc--;
-  argv++;
-
-  if (argc > 0)
-  {
-    from = atol(*argv);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    to = MAX(atol(*argv), from);
-    argc--;
-    argv++;
-  }
-  if (argc > 0)
-  {
-    step = atol(*argv);
-    argc--;
-    argv++;
-  }
-
-  if ((p = getenv("OPENBLAS_LOOPS")))
-    loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))
-    inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step, inc_x, loops);
-
-  if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL)
-  {
-    fprintf(stderr, "Out of Memory!!\n");
-    exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for (m = from; m <= to; m += step)
-  {
-
-    timeg = 0;
-
-    fprintf(stderr, " %6d : ", (int)m);
-
-    for (l = 0; l < loops; l++)
-    {
-
-      for (i = 0; i < m * COMPSIZE * abs(inc_x); i++)
-      {
-        x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
-      }
-
-      begin();
-
-      AMIN(&m, x, &inc_x);
-
-      end();
-
-      timeg += getsec();
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-            " %10.2f MFlops %10.6f sec\n",
-            COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2016, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef AMIN
+
+#ifdef COMPLEX
+#ifdef DOUBLE
+#define AMIN BLASFUNC(dzamin)
+#else
+#define AMIN BLASFUNC(scamin)
+#endif
+#else
+#ifdef DOUBLE
+#define AMIN BLASFUNC(damin)
+#else
+#define AMIN BLASFUNC(samin)
+#endif
+#endif
+
+int main(int argc, char *argv[])
+{
+
+  FLOAT *x;
+  blasint m, i;
+  blasint inc_x = 1;
+  int loops = 1;
+  int l;
+  char *p;
+
+  int from = 1;
+  int to = 200;
+  int step = 1;
+
+  double time1, timeg;
+
+  argc--;
+  argv++;
+
+  if (argc > 0)
+  {
+    from = atol(*argv);
+    argc--;
+    argv++;
+  }
+  if (argc > 0)
+  {
+    to = MAX(atol(*argv), from);
+    argc--;
+    argv++;
+  }
+  if (argc > 0)
+  {
+    step = atol(*argv);
+    argc--;
+    argv++;
+  }
+
+  if ((p = getenv("OPENBLAS_LOOPS")))
+    loops = atoi(p);
+  if ((p = getenv("OPENBLAS_INCX")))
+    inc_x = atoi(p);
+
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step, inc_x, loops);
+
+  if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL)
+  {
+    fprintf(stderr, "Out of Memory!!\n");
+    exit(1);
+  }
+
+#ifdef __linux
+  srandom(getpid());
+#endif
+
+  fprintf(stderr, "   SIZE       Flops\n");
+
+  for (m = from; m <= to; m += step)
+  {
+
+    timeg = 0;
+
+    fprintf(stderr, " %6d : ", (int)m);
+
+    for (l = 0; l < loops; l++)
+    {
+
+      for (i = 0; i < m * COMPSIZE * abs(inc_x); i++)
+      {
+        x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
+      }
+
+      begin();
+
+      AMIN(&m, x, &inc_x);
+
+      end();
+
+      timeg += getsec();
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr,
+            " %10.2f MFlops %10.6f sec\n",
+            COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
+  }
+
+  return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/bench.h

@@ -74,27 +74,10 @@ static void *huge_malloc(BLASLONG size){
 
 #endif
 
-/* Benchmarks should allocate with cacheline (often 64 bytes) alignment
-   to avoid unreliable results. This technique, storing the allocated
-   pointer value just before the aligned memory, doesn't require
-   C11's aligned_alloc for compatibility with older compilers. */
-static void *aligned_alloc_cacheline(size_t n)
-{
-  void *p = malloc((size_t)(void *) + n + L1_DATA_LINESIZE - 1);
-  if (p) {
-    void **newp = (void **)
-      (((uintptr_t)p + L1_DATA_LINESIZE) & (uintptr_t)-L1_DATA_LINESIZE);
-    newp[-1] = p;
-    p = newp;
-  }
-  return p;
-}
-#define malloc aligned_alloc_cacheline
-#define free(p) free((p) ? ((void **)(p))[-1] : (p))
-
 #if defined(__WIN32__) || defined(__WIN64__) || !defined(_POSIX_TIMERS)
   struct timeval start, stop;
 #elif defined(__APPLE__)
+ mach_timebase_info_data_t info;
  uint64_t start = 0, stop = 0;
 #else
   struct timespec start = { 0, 0 }, stop = { 0, 0 };
@@ -105,7 +88,8 @@ double getsec()
 #if defined(__WIN32__) || defined(__WIN64__) || !defined(_POSIX_TIMERS)
     return (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_usec - start.tv_usec)) * 1.e-6;
 #elif defined(__APPLE__)
-    return (double)(stop - start) * 1.e-9;
+    mach_timebase_info(&info);
+    return (double)(((stop - start) * info.numer)/info.denom) * 1.e-9;
 #else
     return (double)(stop.tv_sec - start.tv_sec) + (double)((stop.tv_nsec - start.tv_nsec)) * 1.e-9;
 #endif

benchmark/cblasgemm.c

@@ -1,233 +0,0 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-#include "cblas.h"
-#undef GEMM
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define GEMM   cblas_dgemm
-#elif defined(BFLOAT16) && defined(BGEMM)
-#define GEMM   cblas_bgemm
-#elif defined(BFLOAT16)
-#define GEMM   cblas_sbgemm
-#undef IFLOAT
-#define IFLOAT bfloat16
-#elif defined(HFLOAT16)
-#define GEMM   cblas_shgemm
-#undef IFLOAT
-#define IFLOAT hfloat16
-#else
-#define GEMM   cblas_sgemm
-#undef IFLOAT
-#define IFLOAT float
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define GEMM   cblas_zgemm
-#else
-#define GEMM   cblas_cgemm
-#endif
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  IFLOAT *a, *b;
-  //IFLOAT *aa, *bb;
-  FLOAT *c;
-  //FLOAT *cc;
-#ifdef BGEMM
-  blasint one=1;
-  blasint two=2;
-  float alpha_in[] = {1.0, 0.0};
-  float beta_in[] = {0.0, 0.0};
-  FLOAT alpha[2], beta[2];
-  sbstobf16_(&two, alpha_in, &one, alpha, &one);
-  sbstobf16_(&two, beta_in, &one, beta, &one);
-#else
-#ifdef COMPLEX
-  FLOAT alpha[] = {1.0, 0.0};
-  FLOAT beta [] = {0.0, 0.0};
-#else
-  FLOAT alpha = 1.0;
-  FLOAT beta = 0.0;
-#endif
-#endif
-  CBLAS_TRANSPOSE transa = CblasNoTrans;
-  CBLAS_TRANSPOSE transb = CblasNoTrans;
- char transac, transbc;
-  blasint m, n, k, i, j, lda, ldb, ldc;
-  int loops = 1;
-  int has_param_m = 0;
-  int has_param_n = 0;
-  int has_param_k = 0;
-  int has_param_lda = 0;
-  int has_param_ldb = 0;
-  char *p;
-//blasint sme=0;
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1, timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from = atol(*argv);            argc--; argv++; }
-  if (argc > 0) { to   = MAX(atol(*argv), from); argc--; argv++; }
-  if (argc > 0) { step = atol(*argv);            argc--; argv++; }
-
-  if ((p = getenv("OPENBLAS_TRANS"))) {
-  transa=(*p=='N') ? CblasNoTrans : CblasTrans;
-  transb=(*p=='N') ? CblasNoTrans : CblasTrans;
-  }
-  if ((p = getenv("OPENBLAS_TRANSA"))) {
-  transa=(*p=='N') ? CblasNoTrans : CblasTrans;
-  }
-  if ((p = getenv("OPENBLAS_TRANSB"))) {
-  transb=(*p=='N') ? CblasNoTrans : CblasTrans;
-  }
-
-  transac=(transa==CblasNoTrans) ? 'N' : 'T';
-  transbc=(transb==CblasNoTrans) ? 'N' : 'T';
-  fprintf(stderr, "From : %3d  To : %3d Step=%d : Transa=%c : Transb=%c\n", from, to, step, transac, transbc);
-
-  p = getenv("OPENBLAS_LOOPS");
-  if ( p != NULL ) {
-    loops = atoi(p);
-  }
-
-  if ((p = getenv("OPENBLAS_PARAM_M"))) {
-    m = atoi(p);
-    has_param_m=1;
-  } else {
-    m = to;
-  }
-  if ((p = getenv("OPENBLAS_PARAM_N"))) {
-    n = atoi(p);
-    has_param_n=1;
-  } else {
-    n = to;
-  }
-  if ((p = getenv("OPENBLAS_PARAM_K"))) {
-    k = atoi(p);
-    has_param_k=1;
-  } else {
-    k = to;
-  }
-  if ((p = getenv("OPENBLAS_PARAM_LDA"))) {
-    lda = atoi(p);
-    has_param_lda=1;
-  } 
-  if ((p = getenv("OPENBLAS_PARAM_LDB"))) {
-    ldb = atoi(p);
-    has_param_ldb=1;
-  } 
-
-  if (( a = (IFLOAT *)malloc(sizeof(IFLOAT) * m * k * COMPSIZE)) == NULL) {
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-  if (( b = (IFLOAT *)malloc(sizeof(IFLOAT) * k * n * COMPSIZE)) == NULL) {
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-  if (( c = (FLOAT *)malloc(sizeof(FLOAT) * m * n * COMPSIZE)) == NULL) {
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-  //if (( aa = (IFLOAT *)malloc(sizeof(IFLOAT) * m * k * COMPSIZE)) == NULL) {
-  //  fprintf(stderr,"Out of Memory!!\n");exit(1);
-  //}
-  //if (( bb = (IFLOAT *)malloc(sizeof(IFLOAT) * k * n * COMPSIZE)) == NULL) {
-  //  fprintf(stderr,"Out of Memory!!\n");exit(1);
-  //}
-  //if (( cc = (FLOAT *)malloc(sizeof(FLOAT) * m * n * COMPSIZE)) == NULL) {
-  //  fprintf(stderr,"Out of Memory!!\n");exit(1);
-  //}
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  for (i = 0; i < m * k * COMPSIZE; i++) {
-    a[i] = ((IFLOAT) rand() / (IFLOAT) RAND_MAX) - 0.5;
-  //  aa[i]=a[i];
-  }
-  for (i = 0; i < k * n * COMPSIZE; i++) {
-    b[i] = ((IFLOAT) rand() / (IFLOAT) RAND_MAX) - 0.5;
-  //  bb[i]=b[i];
-  }
-  for (i = 0; i < m * n * COMPSIZE; i++) {
-    c[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-  //  cc[i]=c[i];
-  }
-
-  fprintf(stderr, "          SIZE                   Flops             Time\n");
-
-  for (i = from; i <= to; i += step) {
-    
-    timeg=0;
-
-    if (!has_param_m) { m = i; }
-    if (!has_param_n) { n = i; }
-    if (!has_param_k) { k = i; }
-    
-    if (!has_param_lda) {
-      if (transa == CblasNoTrans) { lda = k; }
-      else { lda = m; }
-    }
-    if (!has_param_ldb) {
-      if (transb == CblasNoTrans) { ldb = n; }
-      else { ldb = k; }
-    }
-    ldc = n;
-
-    fprintf(stderr, " M=%4d, N=%4d, K=%4d : ", (int)m, (int)n, (int)k);
-    begin();
-
-    for (j=0; j<loops; j++) {
-      GEMM (CblasRowMajor,transa, transb, m, n, k, alpha, a, lda, b, ldb, beta, c, ldc);
-    }
-
- // for (ii = 0; ii < m * n * COMPSIZE; ii++) if (fabsf(c[ii]-cc[ii])>1.5e-5){fprintf(stderr,"mismatch %d %f !=  %f: %g\n",ii,c[ii],cc[ii],fabsf(c[ii]-cc[ii]));}
-    end();
-    time1 = getsec();
-
-    timeg = time1/loops;
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)k * (double)m * (double)n / timeg * 1.e-6, time1);
-    
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/gemm.c

@@ -1,4 +1,3 @@
-//#pragma clang optimize off
 /***************************************************************************
 Copyright (c) 2014, The OpenBLAS Project
 All rights reserved.
@@ -34,20 +33,10 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef DOUBLE
 #define GEMM   BLASFUNC(dgemm)
-#elif defined(BFLOAT16) && defined(BGEMM)
-#define GEMM   BLASFUNC(bgemm)
-#elif defined(BFLOAT16)
+#elif defined(HALF)
 #define GEMM   BLASFUNC(sbgemm)
-#undef IFLOAT
-#define IFLOAT bfloat16
-#elif defined(HFLOAT16)
-#define GEMM   BLASFUNC(shgemm)
-#undef IFLOAT
-#define IFLOAT hfloat16
 #else
 #define GEMM   BLASFUNC(sgemm)
-#undef IFLOAT
-#define IFLOAT float
 #endif
 
 #else
@@ -64,18 +53,8 @@ int main(int argc, char *argv[]){
 
   IFLOAT *a, *b;
   FLOAT *c;
-#ifdef BGEMM
-  blasint one=1;
-  blasint two=2;
-  float alpha_in[] = {1.0, 0.0};
-  float beta_in[] = {0.0, 0.0};
-  FLOAT alpha[2], beta[2];
-  sbstobf16_(&two, alpha_in, &one, alpha, &one);
-  sbstobf16_(&two, beta_in, &one, beta, &one);
-#else
   FLOAT alpha[] = {1.0, 0.0};
   FLOAT beta [] = {0.0, 0.0};
-#endif
   char transa = 'N';
   char transb = 'N';
   blasint m, n, k, i, j, lda, ldb, ldc;
@@ -188,7 +167,7 @@ int main(int argc, char *argv[]){
 
     timeg = time1/loops;
     fprintf(stderr,
-	    " %10.2lf MFlops %10.6f sec\n",
+	    " %10.2f MFlops %10.6f sec\n",
 	    COMPSIZE * COMPSIZE * 2. * (double)k * (double)m * (double)n / timeg * 1.e-6, time1);
     
   }

benchmark/gemv.c

@@ -1,5 +1,5 @@
 /***************************************************************************
-Copyright (c) 2014, 2025 The OpenBLAS Project
+Copyright (c) 2014, The OpenBLAS Project
 All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
@@ -34,12 +34,6 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 #ifdef DOUBLE
 #define GEMV   BLASFUNC(dgemv)
-#elif defined(BFLOAT16) && defined(BGEMM)
-#define GEMV   BLASFUNC(bgemv)
-#elif defined(BFLOAT16)
-#define GEMV   BLASFUNC(sbgemv)
-#undef IFLOAT
-#define IFLOAT bfloat16
 #else
 #define GEMV   BLASFUNC(sgemv)
 #endif
@@ -55,20 +49,9 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 #endif
 int main(int argc, char *argv[]){
 
-  IFLOAT *a, *x;
-  FLOAT *y;
-#ifdef BGEMM
-  blasint one=1;
-  blasint two=2;
-  float alpha_in[] = {1.0, 0.0};
-  float beta_in[] = {0.0, 0.0};
-  FLOAT alpha[2], beta[2];
-  sbstobf16_(&two, alpha_in, &one, alpha, &one);
-  sbstobf16_(&two, beta_in, &one, beta, &one);
-#else
-  FLOAT alpha[] = {1.0, 0.0};
-  FLOAT beta [] = {0.0, 0.0};
-#endif
+  FLOAT *a, *x, *y;
+  FLOAT alpha[] = {1.0, 1.0};
+  FLOAT beta [] = {1.0, 0.0};
   char trans='N';
   blasint m, i, j;
   blasint inc_x=1,inc_y=1;
@@ -114,11 +97,11 @@ int main(int argc, char *argv[]){
 
   fprintf(stderr, "From : %3d  To : %3d Step = %3d Trans = '%c' Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,trans,inc_x,inc_y,loops);
 
-  if (( a = (IFLOAT *)malloc(sizeof(IFLOAT) * tomax * tomax * COMPSIZE)) == NULL){
+  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * tomax * tomax * COMPSIZE)) == NULL){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
-  if (( x = (IFLOAT *)malloc(sizeof(IFLOAT) * tomax * abs(inc_x) * COMPSIZE)) == NULL){
+  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * tomax * abs(inc_x) * COMPSIZE)) == NULL){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
@@ -142,7 +125,7 @@ int main(int argc, char *argv[]){
    		fprintf(stderr, " %6dx%d : ", (int)m,(int)n);
    		for(j = 0; j < m; j++){
       			for(i = 0; i < n * COMPSIZE; i++){
-				a[(long)i + (long)j * (long)m * COMPSIZE] = ((IFLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+				a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
       			}
    		}
 
@@ -150,7 +133,7 @@ int main(int argc, char *argv[]){
     		{
 
    			for(i = 0; i < n * COMPSIZE * abs(inc_x); i++){
-				x[i] = ((IFLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+				x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
    			}
 
    			for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){

benchmark/getri.c

@@ -92,7 +92,7 @@ int main(int argc, char *argv[]){
 
   if ((p = getenv("OPENBLAS_TEST"))) btest=*p;
   
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=atoi(p);
+  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
 
   fprintf(stderr, "From : %3d  To : %3d Step = %3d\n", from, to, step);
 

benchmark/hbmv.c

@@ -1,134 +1,134 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef HBMV
-
-#ifdef DOUBLE
-#define HBMV   BLASFUNC(zhbmv)
-#else
-#define HBMV   BLASFUNC(chbmv)
-#endif
-
-int main(int argc, char *argv[]){
-
-    FLOAT *a, *x, *y;
-    FLOAT alpha[] = {1.0, 1.0};
-    FLOAT beta [] = {0.0, 0.0};
-    blasint k = 1;
-    char uplo='L';
-    blasint m, i, j;
-    blasint inc_x=1, inc_y=1;
-    int loops = 1;
-    int l;
-    char *p;
-
-    int from =   1;
-    int to   = 200;
-    int step =   1;
-
-    double time1,timeg;
-
-    argc--;argv++;
-
-    if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-    if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-    if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-    if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-    if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-    if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
-    if ((p = getenv("OPENBLAS_UPLO")))   uplo=*p;
-    if ((p = getenv("OPENBLAS_K")))      k = atoi(p);
-    
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = '%c' k = %d Inc_x = %d Inc_y = %d Loops = %d\n", 
-                            from, to, step, uplo, k, inc_x, inc_y, loops);
-
-    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-    if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for(m = from; m <= to; m += step) {
-
-        timeg=0;
-
-        fprintf(stderr, " %6dx%d : ", (int)m, (int)m);
-
-        for(j = 0; j < m; j++) {
-            for(i = 0; i < m * COMPSIZE; i++) {
-                a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            }
-        }
-
-    for (l = 0; l < loops; l++) {
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_x); i++) {
-            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_y); i++) {
-            y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        begin();
-
-        HBMV (&uplo, &m, &k, alpha, a, &m, x, &inc_x, beta, y, &inc_y );
-
-        end();
-
-        timeg += getsec();
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr, " %10.2f MFlops\n",
-            COMPSIZE * COMPSIZE * 2. * (double)(2 * k + 1) * (double)m / timeg * 1.e-6);
-    }
-
-    return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2014, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef HBMV
+
+#ifdef DOUBLE
+#define HBMV   BLASFUNC(zhbmv)
+#else
+#define HBMV   BLASFUNC(chbmv)
+#endif
+
+int main(int argc, char *argv[]){
+
+    FLOAT *a, *x, *y;
+    FLOAT alpha[] = {1.0, 1.0};
+    FLOAT beta [] = {0.0, 0.0};
+    blasint k = 1;
+    char uplo='L';
+    blasint m, i, j;
+    blasint inc_x=1, inc_y=1;
+    int loops = 1;
+    int l;
+    char *p;
+
+    int from =   1;
+    int to   = 200;
+    int step =   1;
+
+    double time1,timeg;
+
+    argc--;argv++;
+
+    if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
+    if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
+    if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
+
+    if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
+    if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
+    if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
+    if ((p = getenv("OPENBLAS_UPLO")))   uplo=*p;
+    if ((p = getenv("OPENBLAS_K")))      k = atoi(p);
+    
+    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = '%c' k = %d Inc_x = %d Inc_y = %d Loops = %d\n", 
+                            from, to, step, uplo, k, inc_x, inc_y, loops);
+
+    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
+        fprintf(stderr,"Out of Memory!!\n");
+        exit(1);
+    }
+
+    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL) {
+        fprintf(stderr,"Out of Memory!!\n");
+        exit(1);
+    }
+
+    if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL) {
+        fprintf(stderr,"Out of Memory!!\n");
+        exit(1);
+    }
+
+#ifdef __linux
+    srandom(getpid());
+#endif
+
+    fprintf(stderr, "   SIZE       Flops\n");
+
+    for(m = from; m <= to; m += step) {
+
+        timeg=0;
+
+        fprintf(stderr, " %6dx%d : ", (int)m, (int)m);
+
+        for(j = 0; j < m; j++) {
+            for(i = 0; i < m * COMPSIZE; i++) {
+                a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+            }
+        }
+
+    for (l = 0; l < loops; l++) {
+
+        for (i = 0; i < m * COMPSIZE * abs(inc_x); i++) {
+            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+        }
+
+        for (i = 0; i < m * COMPSIZE * abs(inc_y); i++) {
+            y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+        }
+
+        begin();
+
+        HBMV (&uplo, &m, &k, alpha, a, &m, x, &inc_x, beta, y, &inc_y );
+
+        end();
+
+        timeg += getsec();
+
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr, " %10.2f MFlops\n",
+            COMPSIZE * COMPSIZE * 2. * (double)(2 * k + 1) * (double)m / timeg * 1.e-6);
+    }
+
+    return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/hpmv.c

@@ -1,133 +1,133 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef HPMV
-
-#ifdef DOUBLE
-#define HPMV   BLASFUNC(zhpmv)
-#else
-#define HPMV   BLASFUNC(chpmv)
-#endif
-
-int main(int argc, char *argv[]){
-
-    FLOAT *a, *x, *y;
-    FLOAT alpha[] = {1.0, 1.0};
-    FLOAT beta [] = {1.0, 1.0};
-    char uplo='L';
-    blasint m, i, j;
-    blasint inc_x=1, inc_y=1;
-    int loops = 1;
-    int l;
-    char *p;
-
-    int from =   1;
-    int to   = 200;
-    int step =   1;
-
-    double time1,timeg;
-
-    argc--;argv++;
-
-    if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-    if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-    if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-    if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-    if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-    if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
-    if ((p = getenv("OPENBLAS_UPLO")))   uplo=*p;
-
-    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = '%c' Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,uplo,inc_x,inc_y,loops);
-
-    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-    if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL) {
-        fprintf(stderr,"Out of Memory!!\n");
-        exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for(m = from; m <= to; m += step) {
-
-        timeg=0;
-
-        fprintf(stderr, " %6dx%d : ", (int)m, (int)m);
-
-        for(j = 0; j < m; j++) {
-            for(i = 0; i < m * COMPSIZE; i++) {
-                a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-            }
-        }
-
-    for (l = 0; l < loops; l++) {
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_x); i++) {
-            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_y); i++) {
-            y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-        }
-
-        begin();
-
-        HPMV (&uplo, &m, alpha, a, x, &inc_x, beta, y, &inc_y );
-
-        end();
-
-        time1 = getsec();
-
-        timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr, " %10.2f MFlops\n",
-            COMPSIZE * COMPSIZE * 2. * (double)m * (double)m / timeg * 1.e-6);
-    }
-
-    return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2014, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef HPMV
+
+#ifdef DOUBLE
+#define HPMV   BLASFUNC(zhpmv)
+#else
+#define HPMV   BLASFUNC(chpmv)
+#endif
+
+int main(int argc, char *argv[]){
+
+    FLOAT *a, *x, *y;
+    FLOAT alpha[] = {1.0, 1.0};
+    FLOAT beta [] = {1.0, 1.0};
+    char uplo='L';
+    blasint m, i, j;
+    blasint inc_x=1, inc_y=1;
+    int loops = 1;
+    int l;
+    char *p;
+
+    int from =   1;
+    int to   = 200;
+    int step =   1;
+
+    double time1,timeg;
+
+    argc--;argv++;
+
+    if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
+    if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
+    if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
+
+    if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
+    if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
+    if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
+    if ((p = getenv("OPENBLAS_UPLO")))   uplo=*p;
+
+    fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = '%c' Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,uplo,inc_x,inc_y,loops);
+
+    if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
+        fprintf(stderr,"Out of Memory!!\n");
+        exit(1);
+    }
+
+    if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL) {
+        fprintf(stderr,"Out of Memory!!\n");
+        exit(1);
+    }
+
+    if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL) {
+        fprintf(stderr,"Out of Memory!!\n");
+        exit(1);
+    }
+
+#ifdef __linux
+    srandom(getpid());
+#endif
+
+    fprintf(stderr, "   SIZE       Flops\n");
+
+    for(m = from; m <= to; m += step) {
+
+        timeg=0;
+
+        fprintf(stderr, " %6dx%d : ", (int)m, (int)m);
+
+        for(j = 0; j < m; j++) {
+            for(i = 0; i < m * COMPSIZE; i++) {
+                a[i + j * m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+            }
+        }
+
+    for (l = 0; l < loops; l++) {
+
+        for (i = 0; i < m * COMPSIZE * abs(inc_x); i++) {
+            x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+        }
+
+        for (i = 0; i < m * COMPSIZE * abs(inc_y); i++) {
+            y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+        }
+
+        begin();
+
+        HPMV (&uplo, &m, alpha, a, x, &inc_x, beta, y, &inc_y );
+
+        end();
+
+        time1 = getsec();
+
+        timeg += time1;
+
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr, " %10.2f MFlops\n",
+            COMPSIZE * COMPSIZE * 2. * (double)m * (double)m / timeg * 1.e-6);
+    }
+
+    return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/iamin.c

@@ -1,120 +1,120 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef IAMIN
-
-#ifdef COMPLEX
-#ifdef DOUBLE
-#define IAMIN   BLASFUNC(izamin)
-#else
-#define IAMIN   BLASFUNC(icamin)
-#endif
-#else
-#ifdef DOUBLE
-#define IAMIN   BLASFUNC(idamin)
-#else
-#define IAMIN   BLASFUNC(isamin)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	IAMIN (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-
-  }
-  
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2016, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef IAMIN
+
+#ifdef COMPLEX
+#ifdef DOUBLE
+#define IAMIN   BLASFUNC(izamin)
+#else
+#define IAMIN   BLASFUNC(icamin)
+#endif
+#else
+#ifdef DOUBLE
+#define IAMIN   BLASFUNC(idamin)
+#else
+#define IAMIN   BLASFUNC(isamin)
+#endif
+#endif
+
+int main(int argc, char *argv[]){
+
+  FLOAT *x;
+  blasint m, i;
+  blasint inc_x=1;
+  int loops = 1;
+  int l;
+  char *p;
+
+  int from =   1;
+  int to   = 200;
+  int step =   1;
+
+  double time1,timeg;
+
+  argc--;argv++;
+
+  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
+  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
+  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
+
+  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
+  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
+
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
+
+  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
+  }
+
+#ifdef __linux
+  srandom(getpid());
+#endif
+
+  fprintf(stderr, "   SIZE       Flops\n");
+
+  for(m = from; m <= to; m += step)
+  {
+
+   timeg=0;
+
+   fprintf(stderr, " %6d : ", (int)m);
+
+
+   for (l=0; l<loops; l++)
+   {
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+
+    	begin();
+
+    	IAMIN (&m, x, &inc_x);
+
+    	end();
+
+    	time1 = getsec();
+
+	timeg += time1;
+
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr,
+	    " %10.2f MFlops %10.6f sec\n",
+	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
+
+  }
+  
+  return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/imax.c

@@ -1,114 +1,114 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef IMAX
-
-#ifndef COMPLEX
-#ifdef DOUBLE
-#define IMAX   BLASFUNC(idmax)
-#else
-#define IMAX   BLASFUNC(ismax)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	IMAX (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2016, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef IMAX
+
+#ifndef COMPLEX
+#ifdef DOUBLE
+#define IMAX   BLASFUNC(idmax)
+#else
+#define IMAX   BLASFUNC(ismax)
+#endif
+#endif
+
+int main(int argc, char *argv[]){
+
+  FLOAT *x;
+  blasint m, i;
+  blasint inc_x=1;
+  int loops = 1;
+  int l;
+  char *p;
+
+  int from =   1;
+  int to   = 200;
+  int step =   1;
+
+  double time1,timeg;
+
+  argc--;argv++;
+
+  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
+  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
+  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
+
+  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
+  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
+
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
+
+  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
+  }
+
+#ifdef __linux
+  srandom(getpid());
+#endif
+
+  fprintf(stderr, "   SIZE       Flops\n");
+
+  for(m = from; m <= to; m += step)
+  {
+
+   timeg=0;
+
+   fprintf(stderr, " %6d : ", (int)m);
+
+
+   for (l=0; l<loops; l++)
+   {
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+
+    	begin();
+
+    	IMAX (&m, x, &inc_x);
+
+    	end();
+
+    	time1 = getsec();
+
+	timeg += time1;
+
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr,
+	    " %10.2f MFlops %10.6f sec\n",
+	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
+
+  }
+
+  return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/imin.c

@@ -1,114 +1,114 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef IMIN
-
-#ifndef COMPLEX
-#ifdef DOUBLE
-#define IMIN   BLASFUNC(idmin)
-#else
-#define IMIN   BLASFUNC(ismin)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	IMIN (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2016, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef IMIN
+
+#ifndef COMPLEX
+#ifdef DOUBLE
+#define IMIN   BLASFUNC(idmin)
+#else
+#define IMIN   BLASFUNC(ismin)
+#endif
+#endif
+
+int main(int argc, char *argv[]){
+
+  FLOAT *x;
+  blasint m, i;
+  blasint inc_x=1;
+  int loops = 1;
+  int l;
+  char *p;
+
+  int from =   1;
+  int to   = 200;
+  int step =   1;
+
+  double time1,timeg;
+
+  argc--;argv++;
+
+  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
+  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
+  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
+
+  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
+  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
+
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
+
+  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
+  }
+
+#ifdef __linux
+  srandom(getpid());
+#endif
+
+  fprintf(stderr, "   SIZE       Flops\n");
+
+  for(m = from; m <= to; m += step)
+  {
+
+   timeg=0;
+
+   fprintf(stderr, " %6d : ", (int)m);
+
+
+   for (l=0; l<loops; l++)
+   {
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+
+    	begin();
+
+    	IMIN (&m, x, &inc_x);
+
+    	end();
+
+    	time1 = getsec();
+
+	timeg += time1;
+
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr,
+	    " %10.2f MFlops %10.6f sec\n",
+	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
+
+  }
+
+  return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/linpack.c

@@ -85,7 +85,7 @@ int main(int argc, char *argv[]){
   double time1, time2, timeg1,timeg2;
 
   char *p;
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=atoi(p);
+  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
   
   argc--;argv++;
 

benchmark/max.c

@@ -1,113 +1,113 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef NAMAX
-
-#ifndef COMPLEX
-#ifdef DOUBLE
-#define NAMAX   BLASFUNC(dmax)
-#else
-#define NAMAX   BLASFUNC(smax)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	NAMAX (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2016, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef NAMAX
+
+#ifndef COMPLEX
+#ifdef DOUBLE
+#define NAMAX   BLASFUNC(dmax)
+#else
+#define NAMAX   BLASFUNC(smax)
+#endif
+#endif
+
+int main(int argc, char *argv[]){
+
+  FLOAT *x;
+  blasint m, i;
+  blasint inc_x=1;
+  int loops = 1;
+  int l;
+  char *p;
+
+  int from =   1;
+  int to   = 200;
+  int step =   1;
+
+  double time1,timeg;
+
+  argc--;argv++;
+
+  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
+  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
+  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
+
+  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
+  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
+
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
+
+  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
+  }
+
+#ifdef __linux
+  srandom(getpid());
+#endif
+
+  fprintf(stderr, "   SIZE       Flops\n");
+
+  for(m = from; m <= to; m += step)
+  {
+
+   timeg=0;
+
+   fprintf(stderr, " %6d : ", (int)m);
+
+
+   for (l=0; l<loops; l++)
+   {
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+
+    	begin();
+
+    	NAMAX (&m, x, &inc_x);
+
+    	end();
+
+    	time1 = getsec();
+
+	timeg += time1;
+
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr,
+	    " %10.2f MFlops %10.6f sec\n",
+	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
+  }
+
+  return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/min.c

@@ -1,113 +1,113 @@
-/***************************************************************************
-Copyright (c) 2016, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef NAMIN
-
-#ifndef COMPLEX
-#ifdef DOUBLE
-#define NAMIN   BLASFUNC(dmin)
-#else
-#define NAMIN   BLASFUNC(smin)
-#endif
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *x;
-  blasint m, i;
-  blasint inc_x=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6d : ", (int)m);
-
-
-   for (l=0; l<loops; l++)
-   {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-    	begin();
-
-    	NAMIN (&m, x, &inc_x);
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2016, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef NAMIN
+
+#ifndef COMPLEX
+#ifdef DOUBLE
+#define NAMIN   BLASFUNC(dmin)
+#else
+#define NAMIN   BLASFUNC(smin)
+#endif
+#endif
+
+int main(int argc, char *argv[]){
+
+  FLOAT *x;
+  blasint m, i;
+  blasint inc_x=1;
+  int loops = 1;
+  int l;
+  char *p;
+
+  int from =   1;
+  int to   = 200;
+  int step =   1;
+
+  double time1,timeg;
+
+  argc--;argv++;
+
+  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
+  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
+  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
+
+  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
+  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
+
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Inc_x = %d Loops = %d\n", from, to, step,inc_x,loops);
+
+  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
+  }
+
+#ifdef __linux
+  srandom(getpid());
+#endif
+
+  fprintf(stderr, "   SIZE       Flops\n");
+
+  for(m = from; m <= to; m += step)
+  {
+
+   timeg=0;
+
+   fprintf(stderr, " %6d : ", (int)m);
+
+
+   for (l=0; l<loops; l++)
+   {
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+
+    	begin();
+
+    	NAMIN (&m, x, &inc_x);
+
+    	end();
+
+    	time1 = getsec();
+
+	timeg += time1;
+
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr,
+	    " %10.2f MFlops %10.6f sec\n",
+	    COMPSIZE * sizeof(FLOAT) * 1. * (double)m / timeg * 1.e-6, timeg);
+  }
+
+  return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/omatcopy.c

@@ -1,122 +0,0 @@
-/***************************************************************************
-Copyright (c) 2024, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef OMATCOPY
-
-#ifndef COMPLEX
-#ifdef DOUBLE
-#define OMATCOPY BLASFUNC(domatcopy)
-#else
-#define OMATCOPY BLASFUNC(somatcopy)
-#endif
-#else
-#ifdef DOUBLE
-#define OMATCOPY BLASFUNC(zomatcopy)
-#else
-#define OMATCOPY BLASFUNC(comatcopy)
-#endif
-#endif
-int main(int argc, char *argv[]){
-  FLOAT *a, *b;
-  FLOAT alpha[] = {1.0, 0.0};
-  char trans = 'N';
-  char order = 'C';
-  blasint crows, ccols, clda, cldb;
-  int loops = 1;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-  int i, j;
-
-  double time1, timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from = atol(*argv);            argc--; argv++; }
-  if (argc > 0) { to   = MAX(atol(*argv), from); argc--; argv++; }
-  if (argc > 0) { step = atol(*argv);            argc--; argv++; }
-
-  if ((p = getenv("OPENBLAS_TRANS"))) {
-    trans=*p;
-  }
-  if ((p = getenv("OPENBLAS_ORDER"))) {
-    order=*p;
-  }
-  TOUPPER(trans);
-  TOUPPER(order);
-  fprintf(stderr, "From : %3d  To : %3d Step=%d : Trans=%c : Order=%c\n", from, to, step, trans, order);
-  p = getenv("OPENBLAS_LOOPS");
-  if ( p != NULL ) {
-    loops = atoi(p);
-  }
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-  if (( b = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL) {
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  for (i = 0; i < to * to * COMPSIZE; i++) {
-    a[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-  }
-  for (i = 0; i < to * to * COMPSIZE; i++) {
-    b[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-  }
-
-  fprintf(stderr, "          SIZE                   Flops             Time\n");
-  for (i = from; i <= to; i += step) {
-    cldb = clda = crows = ccols = i;
-    fprintf(stderr, " ROWS=%4d, COLS=%4d : ", (int)crows, (int)ccols);
-    begin();
-
-    for (j=0; j<loops; j++) {
-      OMATCOPY (&order, &trans, &crows, &ccols, alpha, a, &clda, b, &cldb);
-    }
-
-    end();
-    time1 = getsec();
-
-    timeg = time1/loops;
-    fprintf(stderr,
-	    " %10.2f MFlops %10.6f sec\n",
-	    COMPSIZE * COMPSIZE * (double)ccols * (double)crows / timeg * 1.e-6, time1);
-  }
-
-  free(a);
-  free(b);
-
-  return 0;
-}

benchmark/potrf.c

@@ -120,7 +120,7 @@ int main(int argc, char *argv[]){
 
   if ((p = getenv("OPENBLAS_TEST"))) btest=*p;
 
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=atoi(p);
+  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
 
   fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c\n", from, to, step,*uplo[uplos]);
 

benchmark/pybench/README.md

@@ -1,59 +0,0 @@
-# Continuous benchmarking of OpenBLAS performance
-
-We run a set of benchmarks of subset of OpenBLAS functionality.
-
-## Benchmark runner
-
-[![CodSpeed Badge](https://img.shields.io/endpoint?url=https://codspeed.io/badge.json)](https://codspeed.io/OpenMathLib/OpenBLAS/)
-
-Click on [benchmarks](https://codspeed.io/OpenMathLib/OpenBLAS/benchmarks) to see the performance of a particular benchmark over time;
-Click on [branches](https://codspeed.io/OpenMathLib/OpenBLAS/branches/) and then on the last PR link to see the flamegraphs.
-
-## What are the benchmarks
-
-We run raw BLAS/LAPACK subroutines, via f2py-generated python wrappers. The wrappers themselves are equivalent to [those from SciPy](https://docs.scipy.org/doc/scipy/reference/linalg.lapack.html).
-In fact, the wrappers _are_ from SciPy, we take a small subset simply to avoid having to build the whole SciPy for each CI run.
-
-
-## Adding a new benchmark
-
-`.github/workflows/codspeed-bench.yml` does all the orchestration on CI.
-
-Benchmarks live in the `benchmark/pybench` directory. It is organized as follows:
-
-- benchmarks themselves live in the `benchmarks` folder. Note that the LAPACK routines are imported from the `openblas_wrap` package.
-- the `openblas_wrap` package is a simple trampoline: it contains an f2py extension, `_flapack`, which talks to OpenBLAS, and exports the python names in its `__init__.py`.
-This way, the `openblas_wrap` package shields the benchmarks from the details of where a particular LAPACK function comes from. If wanted, you may for instance swap the `_flapack` extension to
-`scipy.linalg.blas` and `scipy.linalg.lapack`.
-
-To change parameters of an existing benchmark, edit python files in the `benchmark/pybench/benchmarks` directory.
-
-To add a benchmark for a new BLAS or LAPACK function, you need to:
-
-- add an f2py wrapper for the bare LAPACK function. You can simply copy a wrapper from SciPy (look for `*.pyf.src` files in https://github.com/scipy/scipy/tree/main/scipy/linalg)
-- add an import to `benchmark/pybench/openblas_wrap/__init__.py`
-
-
-## Running benchmarks locally
-
-This benchmarking layer is orchestrated from python, therefore you'll need to
-have all what it takes to build OpenBLAS from source, plus `python` and
-
-```
-$ python -mpip install numpy meson ninja pytest pytest-benchmark
-```
-
-The Meson build system looks for the installed OpenBLAS using pkgconfig, so the openblas.pc created during the OpenBLAS build needs
-to be somewhere on the search path of pkgconfig or in a folder pointed to by the environment variable PKG_CONFIG_PATH.
-
-If you want to build the benchmark suite using flang (or flang-new) instead of gfortran for the Fortran parts, you currently need
-to edit the meson.build file and change the line `'fortran_std=legacy'` to `'fortran_std=none'` to work around an incompatibility
-between Meson and flang.
-
-If you are building and running the benchmark under MS Windows, it may be necessary to copy the generated openblas_wrap module from
-your build folder to the `benchmarks` folder.
-
-The benchmark syntax is consistent with that of `pytest-benchmark` framework. The incantation to run the suite locally is `$ pytest benchmark/pybench/benchmarks/bench_blas.py`.
-
-An ASV compatible benchmark suite is planned but currently not implemented.
-

benchmark/pybench/benchmarks/bench_blas.py

@@ -1,274 +0,0 @@
-import pytest
-import numpy as np
-import openblas_wrap as ow
-
-dtype_map = {
-    's': np.float32,
-    'd': np.float64,
-    'c': np.complex64,
-    'z': np.complex128,
-    'dz': np.complex128,
-}
-
-
-# ### BLAS level 1 ###
-
-# dnrm2
-
-dnrm2_sizes = [100, 1000]
-
-def run_dnrm2(n, x, incx, func):
-    res = func(x, n, incx=incx)
-    return res
-
-
-@pytest.mark.parametrize('variant', ['d', 'dz'])
-@pytest.mark.parametrize('n', dnrm2_sizes)
-def test_nrm2(benchmark, n, variant):
-    rndm = np.random.RandomState(1234)
-    dtyp = dtype_map[variant]
-
-    x = np.array(rndm.uniform(size=(n,)), dtype=dtyp)
-    nrm2 = ow.get_func('nrm2', variant)
-    result = benchmark(run_dnrm2, n, x, 1, nrm2)
-
-
-# ddot
-
-ddot_sizes = [100, 1000]
-
-def run_ddot(x, y, func):
-    res = func(x, y)
-    return res
-
-
-@pytest.mark.parametrize('n', ddot_sizes)
-def test_dot(benchmark, n):
-    rndm = np.random.RandomState(1234)
-
-    x = np.array(rndm.uniform(size=(n,)), dtype=float)
-    y = np.array(rndm.uniform(size=(n,)), dtype=float)
-    dot = ow.get_func('dot', 'd')
-    result = benchmark(run_ddot, x, y, dot)
-
-
-# daxpy
-
-daxpy_sizes = [100, 1000]
-
-def run_daxpy(x, y, func):
-    res = func(x, y, a=2.0)
-    return res
-
-
-@pytest.mark.parametrize('variant', ['s', 'd', 'c', 'z'])
-@pytest.mark.parametrize('n', daxpy_sizes)
-def test_daxpy(benchmark, n, variant):
-    rndm = np.random.RandomState(1234)
-    dtyp = dtype_map[variant]
-
-    x = np.array(rndm.uniform(size=(n,)), dtype=dtyp)
-    y = np.array(rndm.uniform(size=(n,)), dtype=dtyp)
-    axpy = ow.get_func('axpy', variant)
-    result = benchmark(run_daxpy, x, y, axpy)
-
-
-# ### BLAS level 2 ###
-
-gemv_sizes = [100, 1000]
-
-def run_gemv(a, x, y, func):
-    res = func(1.0, a, x, y=y, overwrite_y=True)
-    return res
-
-
-@pytest.mark.parametrize('variant', ['s', 'd', 'c', 'z'])
-@pytest.mark.parametrize('n', gemv_sizes)
-def test_dgemv(benchmark, n, variant):
-    rndm = np.random.RandomState(1234)
-    dtyp = dtype_map[variant]
-
-    x = np.array(rndm.uniform(size=(n,)), dtype=dtyp)
-    y = np.empty(n, dtype=dtyp)
-
-    a = np.array(rndm.uniform(size=(n,n)), dtype=dtyp)
-    x = np.array(rndm.uniform(size=(n,)), dtype=dtyp)
-    y = np.zeros(n, dtype=dtyp)
-
-    gemv = ow.get_func('gemv', variant)
-    result = benchmark(run_gemv, a, x, y, gemv)
-
-    assert result is y
-
-
-# dgbmv
-
-dgbmv_sizes = [100, 1000]
-
-def run_gbmv(m, n, kl, ku, a, x, y, func):
-    res = func(m, n, kl, ku, 1.0, a, x, y=y, overwrite_y=True)
-    return res
-
-
-
-@pytest.mark.parametrize('variant', ['s', 'd', 'c', 'z'])
-@pytest.mark.parametrize('n', dgbmv_sizes)
-@pytest.mark.parametrize('kl', [1])
-def test_dgbmv(benchmark, n, kl, variant):
-    rndm = np.random.RandomState(1234)
-    dtyp = dtype_map[variant]
-
-    x = np.array(rndm.uniform(size=(n,)), dtype=dtyp)
-    y = np.empty(n, dtype=dtyp)
-
-    m = n
-
-    a = rndm.uniform(size=(2*kl + 1, n))
-    a = np.array(a, dtype=dtyp, order='F')
-
-    gbmv = ow.get_func('gbmv', variant)
-    result = benchmark(run_gbmv, m, n, kl, kl, a, x, y, gbmv)
-    assert result is y
-
-
-# ### BLAS level 3 ###
-
-# dgemm
-
-gemm_sizes = [100, 1000]
-
-def run_gemm(a, b, c, func):
-    alpha = 1.0
-    res = func(alpha, a, b, c=c, overwrite_c=True)
-    return res
-
-
-@pytest.mark.parametrize('variant', ['s', 'd', 'c', 'z'])
-@pytest.mark.parametrize('n', gemm_sizes)
-def test_gemm(benchmark, n, variant):
-    rndm = np.random.RandomState(1234)
-    dtyp = dtype_map[variant]
-    a = np.array(rndm.uniform(size=(n, n)), dtype=dtyp, order='F')
-    b = np.array(rndm.uniform(size=(n, n)), dtype=dtyp, order='F')
-    c = np.empty((n, n), dtype=dtyp, order='F')
-    gemm = ow.get_func('gemm', variant)
-    result = benchmark(run_gemm, a, b, c, gemm)
-    assert result is c
-
-
-# dsyrk
-
-syrk_sizes = [100, 1000]
-
-
-def run_syrk(a, c, func):
-    res = func(1.0, a, c=c, overwrite_c=True)
-    return res
-
-
-@pytest.mark.parametrize('variant', ['s', 'd', 'c', 'z'])
-@pytest.mark.parametrize('n', syrk_sizes)
-def test_syrk(benchmark, n, variant):
-    rndm = np.random.RandomState(1234)
-    dtyp = dtype_map[variant]
-    a = np.array(rndm.uniform(size=(n, n)), dtype=dtyp, order='F')
-    c = np.empty((n, n), dtype=dtyp, order='F')
-    syrk = ow.get_func('syrk', variant)
-    result = benchmark(run_syrk, a, c, syrk)
-    assert result is c
-
-
-# ### LAPACK ###
-
-# linalg.solve
-
-gesv_sizes = [100, 1000]
-
-
-def run_gesv(a, b, func):
-    res = func(a, b, overwrite_a=True, overwrite_b=True)
-    return res
-
-
-@pytest.mark.parametrize('variant', ['s', 'd', 'c', 'z'])
-@pytest.mark.parametrize('n', gesv_sizes)
-def test_gesv(benchmark, n, variant):
-    rndm = np.random.RandomState(1234)
-    dtyp = dtype_map[variant]
-
-    a = (np.array(rndm.uniform(size=(n, n)), dtype=dtyp, order='F') +
-         np.eye(n, dtype=dtyp, order='F'))
-    b = np.array(rndm.uniform(size=(n, 1)), dtype=dtyp, order='F')
-    gesv = ow.get_func('gesv', variant)
-    lu, piv, x, info = benchmark(run_gesv, a, b, gesv)
-    assert lu is a
-    assert x is b
-    assert info == 0
-
-
-# linalg.svd
-
-gesdd_sizes = [(100, 5), (1000, 222)]
-
-
-def run_gesdd(a, lwork, func):
-    res = func(a, lwork=lwork, full_matrices=False, overwrite_a=False)
-    return res
-
-
-@pytest.mark.parametrize('variant', ['s', 'd'])
-@pytest.mark.parametrize('mn', gesdd_sizes)
-def test_gesdd(benchmark, mn, variant):
-    m, n = mn
-    rndm = np.random.RandomState(1234)
-    dtyp = dtype_map[variant]
-
-    a = np.array(rndm.uniform(size=(m, n)), dtype=dtyp, order='F')
-
-    gesdd_lwork = ow.get_func('gesdd_lwork', variant)
-
-    lwork, info = gesdd_lwork(m, n)
-    lwork = int(lwork)
-    assert info == 0
-
-    gesdd = ow.get_func('gesdd', variant)
-    u, s, vt, info = benchmark(run_gesdd, a, lwork, gesdd)
-
-    assert info == 0
-
-    atol = {'s': 5e-5, 'd': 1e-13}
-    np.testing.assert_allclose(u @ np.diag(s) @ vt, a, atol=atol[variant])
-
-
-# linalg.eigh
-
-syev_sizes = [50, 200]
-
-
-def run_syev(a, lwork, func):
-    res = func(a, lwork=lwork, overwrite_a=True)
-    return res
-
-
-@pytest.mark.parametrize('variant', ['s', 'd'])
-@pytest.mark.parametrize('n', syev_sizes)
-def test_syev(benchmark, n, variant):
-    rndm = np.random.RandomState(1234)
-    dtyp = dtype_map[variant]
-
-    a = rndm.uniform(size=(n, n))
-    a = np.asarray(a + a.T, dtype=dtyp, order='F')
-    a_ = a.copy()
-
-    dsyev_lwork = ow.get_func('syev_lwork', variant)
-    lwork, info = dsyev_lwork(n)
-    lwork = int(lwork)
-    assert info == 0
-
-    syev = ow.get_func('syev', variant)
-    w, v, info = benchmark(run_syev, a, lwork, syev)
-
-    assert info == 0
-    assert a is v  # overwrite_a=True
-
-

benchmark/pybench/meson.build

@@ -1,48 +0,0 @@
-#
-# Taken from SciPy (of course)
-#
-project(
-  'openblas-wrap',
-  'c', 'fortran',
-  version: '0.1',
-  license: 'BSD-3',
-  meson_version: '>= 1.1.0',
-  default_options: [
-    'buildtype=debugoptimized',
-    'b_ndebug=if-release',
-    'c_std=c17',
-    'fortran_std=legacy',
-  ],
-)
-
-py3 = import('python').find_installation(pure: false)
-py3_dep = py3.dependency()
-
-cc = meson.get_compiler('c')
-
-_global_c_args = cc.get_supported_arguments(
-  '-Wno-unused-but-set-variable',
-  '-Wno-unused-function',
-  '-Wno-conversion',
-  '-Wno-misleading-indentation',
-)
-add_project_arguments(_global_c_args, language : 'c')
-
-# We need -lm for all C code (assuming it uses math functions, which is safe to
-# assume for SciPy). For C++ it isn't needed, because libstdc++/libc++ is
-# guaranteed to depend on it. For Fortran code, Meson already adds `-lm`.
-m_dep = cc.find_library('m', required : false)
-if m_dep.found()
-  add_project_link_arguments('-lm', language : 'c')
-endif
-
-generate_f2pymod = find_program('openblas_wrap/generate_f2pymod.py')
-
-openblas = dependency('openblas', method: 'pkg-config', required: true)
-openblas_dep = declare_dependency(
-  dependencies: openblas,
-  compile_args: []
-)
-
-
-subdir('openblas_wrap')

benchmark/pybench/openblas_wrap/__init__.py

@@ -1,17 +0,0 @@
-"""
-Trampoline to hide the LAPACK details (scipy.lapack.linalg or scipy_openblas32 or...)
-from benchmarking.
-"""
-
-__version__ = "0.1"  
-
-
-from . import _flapack
-
-PREFIX = ''
-
-
-def get_func(name, variant):
-    """get_func('gesv', 'c') -> cgesv etc."""
-    return getattr(_flapack, PREFIX + variant + name)
-

benchmark/pybench/openblas_wrap/blas_lapack.pyf.src

@@ -1,417 +0,0 @@
-!
-! Taken from scipy/linalg
-!
-! Shorthand notations
-!
-! <tchar=s,d,cs,zd>
-! <tchar2c=cs,zd>
-!
-! <prefix2=s,d>
-! <prefix2c=c,z>
-! <prefix3=s,sc>
-! <prefix4=d,dz>
-! <prefix6=s,d,c,z,c,z>
-!
-! <ftype2=real,double precision>
-! <ftype2c=complex,double complex>
-! <ftype3=real,complex>
-! <ftype4=double precision,double complex>
-! <ftypereal3=real,real>
-! <ftypereal4=double precision,double precision>
-! <ftype6=real,double precision,complex,double complex,\2,\3>
-! <ftype6creal=real,double precision,complex,double complex,\0,\1>
-!
-! <ctype2=float,double>
-! <ctype2c=complex_float,complex_double>
-! <ctype3=float,complex_float>
-! <ctype4=double,complex_double>
-! <ctypereal3=float,float>
-! <ctypereal4=double,double>
-! <ctype6=float,double,complex_float,complex_double,\2,\3>
-! <ctype6creal=float,double,complex_float,complex_double,\0,\1>
-!
-!
-! Level 1 BLAS
-!
-
-
-python module _flapack
-    usercode '''
-#define F_INT int
-'''
-
-interface
-
-
-subroutine <prefix>axpy(n,a,x,offx,incx,y,offy,incy)
-  ! Calculate z = a*x+y, where a is scalar.
-
-  callstatement (*f2py_func)(&n,&a,x+offx,&incx,y+offy,&incy)
-  callprotoargument F_INT*,<ctype>*,<ctype>*,F_INT*,<ctype>*,F_INT*
-
-  <ftype> dimension(*), intent(in) :: x
-  <ftype> dimension(*), intent(in,out,out=z) :: y
-  <ftype> optional, intent(in):: a=<1.0,\0,(1.0\,0.0),\2>
-  integer optional, intent(in),check(incx>0||incx<0) :: incx = 1
-  integer optional, intent(in),check(incy>0||incy<0) :: incy = 1
-  integer optional, intent(in),depend(x) :: offx=0
-  integer optional, intent(in),depend(y) :: offy=0
-  check(offx>=0 && offx<len(x)) :: offx
-  check(offy>=0 && offy<len(y)) :: offy
-  integer optional, intent(in),depend(x,incx,offx,y,incy,offy) :: &
-       n = (len(x)-offx)/abs(incx)
-  check(len(x)-offx>(n-1)*abs(incx)) :: n
-  check(len(y)-offy>(n-1)*abs(incy)) :: n
-
-end subroutine <prefix>axpy
-
-function ddot(n,x,offx,incx,y,offy,incy) result (xy)
-  ! Computes a vector-vector dot product.
-
-  callstatement ddot_return_value = (*f2py_func)(&n,x+offx,&incx,y+offy,&incy)
-  callprotoargument F_INT*,double*,F_INT*,double*,F_INT*
-  intent(c) ddot
-  fortranname F_FUNC(ddot,DDOT)
-
-  double precision dimension(*), intent(in) :: x
-  double precision dimension(*), intent(in) :: y
-  double precision ddot,xy
-  integer optional, intent(in),check(incx>0||incx<0) :: incx = 1
-  integer optional, intent(in),check(incy>0||incy<0) :: incy = 1
-  integer optional, intent(in),depend(x) :: offx=0
-  integer optional, intent(in),depend(y) :: offy=0
-  check(offx>=0 && offx<len(x)) :: offx
-  check(offy>=0 && offy<len(y)) :: offy
-  integer optional, intent(in),depend(x,incx,offx,y,incy,offy) :: &
-       n = (len(x)-offx)/abs(incx)
-  check(len(x)-offx>(n-1)*abs(incx)) :: n
-  check(len(y)-offy>(n-1)*abs(incy)) :: n
-
-end function ddot
-
-
-function <prefix4>nrm2(n,x,offx,incx) result(n2)
-
-  <ftypereal4> <prefix4>nrm2, n2
-
-  callstatement <prefix4>nrm2_return_value = (*f2py_func)(&n,x+offx,&incx)
-  callprotoargument F_INT*,<ctype4>*,F_INT*
-  intent(c) <prefix4>nrm2
-  fortranname F_FUNC(<prefix4>nrm2,<D,DZ>NRM2)
-
-  <ftype4> dimension(*),intent(in) :: x
-
-  integer optional, intent(in),check(incx>0) :: incx = 1
-
-  integer optional,intent(in),depend(x) :: offx=0
-  check(offx>=0 && offx<len(x)) :: offx
-
-  integer optional,intent(in),depend(x,incx,offx) :: n = (len(x)-offx)/abs(incx)
-  check(len(x)-offx>(n-1)*abs(incx)) :: n
-
-end function <prefix4>nrm2
-
-
-!
-! Level 2 BLAS
-!
-
-
-subroutine <prefix>gemv(m,n,alpha,a,x,beta,y,offx,incx,offy,incy,trans,rows,cols,ly)
-  ! Computes a matrix-vector product using a general matrix
-  !
-  ! y = gemv(alpha,a,x,beta=0,y=0,offx=0,incx=1,offy=0,incy=0,trans=0)
-  ! Calculate y <- alpha * op(A) * x + beta * y
-
-  callstatement (*f2py_func)((trans?(trans==2?"C":"T"):"N"),&m,&n,&alpha,a,&m, &
-       x+offx,&incx,&beta,y+offy,&incy)
-  callprotoargument char*,F_INT*,F_INT*,<ctype>*,<ctype>*,F_INT*,<ctype>*,F_INT*,<ctype>*, &
-       <ctype>*,F_INT*
-
-  integer optional, intent(in), check(trans>=0 && trans <=2) :: trans = 0
-  integer optional, intent(in), check(incx>0||incx<0) :: incx = 1
-  integer optional, intent(in), check(incy>0||incy<0) :: incy = 1
-  <ftype> intent(in) :: alpha
-  <ftype> intent(in), optional :: beta = <0.0,\0,(0.0\,0.0),\2>
-
-  <ftype> dimension(*), intent(in) :: x
-  <ftype> dimension(ly), intent(in,copy,out), depend(ly),optional :: y
-  integer intent(hide), depend(incy,rows,offy) :: ly = &
-       (y_capi==Py_None?1+offy+(rows-1)*abs(incy):-1)
-  <ftype> dimension(m,n), intent(in) :: a
-  integer depend(a), intent(hide):: m = shape(a,0)
-  integer depend(a), intent(hide):: n = shape(a,1)
-
-  integer optional, intent(in) :: offx=0
-  integer optional, intent(in) :: offy=0
-  check(offx>=0 && offx<len(x)) :: x
-  check(len(x)>offx+(cols-1)*abs(incx)) :: x
-  depend(offx,cols,incx) :: x
-
-  check(offy>=0 && offy<len(y)) :: y
-  check(len(y)>offy+(rows-1)*abs(incy)) :: y
-  depend(offy,rows,incy) :: y
-
-  integer depend(m,n,trans), intent(hide) :: rows = (trans?n:m)
-  integer depend(m,n,trans), intent(hide) :: cols = (trans?m:n)
-
-end subroutine <prefix>gemv
-
-
-subroutine <prefix>gbmv(m,n,kl,ku,alpha,a,lda,x,incx,offx,beta,y,incy,offy,trans,ly)
-  ! Performs one of the matrix-vector operations
-  !
-  !    y := alpha*A*x + beta*y,   or   y := alpha*A**T*x + beta*y,
-  !                               or   y := alpha*A**H*x + beta*y,
-  !
-  ! where alpha and beta are scalars, x and y are vectors and A is an
-  ! m by n band matrix, with kl sub-diagonals and ku super-diagonals.
-
-  callstatement (*f2py_func)((trans?(trans==2?"C":"T"):"N"),&m,&n,&kl,&ku,&alpha,a,&lda,x+offx,&incx,&beta,y+offy,&incy)
-  callprotoargument char*,F_INT*,F_INT*,F_INT*,F_INT*,<ctype>*,<ctype>*,F_INT*,<ctype>*,F_INT*,<ctype>*,<ctype>*,F_INT*
-
-  integer optional,intent(in),check(trans>=0 && trans <=2) :: trans = 0
-  integer intent(in), depend(ku,kl),check(m>=ku+kl+1) :: m
-  integer intent(in),check(n>=0&&n==shape(a,1)),depend(a) :: n
-  integer intent(in),check(kl>=0) :: kl
-  integer intent(in),check(ku>=0) :: ku
-  integer intent(hide),depend(a) :: lda = MAX(shape(a,0),1)
-  integer optional, intent(in),check(incx>0||incx<0) :: incx = 1
-  integer optional, intent(in),check(incy>0||incy<0) :: incy = 1
-  integer intent(hide),depend(m,n,incy,offy,trans) :: ly = &
-      (y_capi==Py_None?1+offy+(trans==0?m-1:n-1)*abs(incy):-1)
-  integer optional, intent(in) :: offx=0
-  integer optional, intent(in) :: offy=0
-
-  <ftype> intent(in) :: alpha
-  <ftype> intent(in),optional :: beta = <0.0,\0,(0.0\,0.0),\2>
-
-  <ftype> dimension(lda,n),intent(in) :: a
-
-  <ftype> dimension(ly), intent(in,out,copy,out=yout),depend(ly),optional :: y
-  check(offy>=0 && offy<len(y)) :: y
-  check(len(y)>offy+(trans==0?m-1:n-1)*abs(incy)) :: y
-  depend(offy,n,incy) :: y
-
-  <ftype> dimension(*), intent(in) :: x
-  check(offx>=0 && offx<len(x)) :: x
-  check(len(x)>offx+(trans==0?n-1:m-1)*abs(incx)) :: x
-  depend(offx,n,incx) :: x
-
-end subroutine <prefix>gbmv
-
-
-
-!
-! Level 3 BLAS
-!
-
-
-subroutine <prefix>gemm(m,n,k,alpha,a,b,beta,c,trans_a,trans_b,lda,ka,ldb,kb)
-  ! Computes a scalar-matrix-matrix product and adds the result to a
-  ! scalar-matrix product.
-  !
-  ! c = gemm(alpha,a,b,beta=0,c=0,trans_a=0,trans_b=0,overwrite_c=0)
-  ! Calculate C <- alpha * op(A) * op(B) + beta * C
-
-  callstatement (*f2py_func)((trans_a?(trans_a==2?"C":"T"):"N"), &
-       (trans_b?(trans_b==2?"C":"T"):"N"),&m,&n,&k,&alpha,a,&lda,b,&ldb,&beta,c,&m)
-  callprotoargument char*,char*,F_INT*,F_INT*,F_INT*,<ctype>*,<ctype>*,F_INT*,<ctype>*, &
-       F_INT*,<ctype>*,<ctype>*,F_INT*
-
-  integer optional,intent(in),check(trans_a>=0 && trans_a <=2) :: trans_a = 0
-  integer optional,intent(in),check(trans_b>=0 && trans_b <=2) :: trans_b = 0
-  <ftype> intent(in) :: alpha
-  <ftype> intent(in),optional :: beta = <0.0,\0,(0.0\,0.0),\2>
-
-  <ftype> dimension(lda,ka),intent(in) :: a
-  <ftype> dimension(ldb,kb),intent(in) :: b
-  <ftype> dimension(m,n),intent(in,out,copy),depend(m,n),optional :: c
-  check(shape(c,0)==m && shape(c,1)==n) :: c
-
-  integer depend(a),intent(hide) :: lda = shape(a,0)
-  integer depend(a),intent(hide) :: ka = shape(a,1)
-  integer depend(b),intent(hide) :: ldb = shape(b,0)
-  integer depend(b),intent(hide) :: kb = shape(b,1)
-
-  integer depend(a,trans_a,ka,lda),intent(hide):: m = (trans_a?ka:lda)
-  integer depend(a,trans_a,ka,lda),intent(hide):: k = (trans_a?lda:ka)
-  integer depend(b,trans_b,kb,ldb,k),intent(hide),check(trans_b?kb==k:ldb==k) :: &
-       n = (trans_b?ldb:kb)
-
-end subroutine <prefix>gemm
-
-
-subroutine <prefix6><sy,\0,\0,\0,he,he>rk(n,k,alpha,a,beta,c,trans,lower,lda,ka)
-  !  performs one of the symmetric rank k operations
-  !     C := alpha*A*A**T + beta*C,  or   C := alpha*A**T*A + beta*C,
-  !
-  ! c = syrk(alpha,a,beta=0,c=0,trans=0,lower=0,overwrite_c=0)
-  !
-  callstatement (*f2py_func)((lower?"L":"U"), &
-        (trans?(trans==2?"C":"T"):"N"), &n,&k,&alpha,a,&lda,&beta,c,&n)
-  callprotoargument char*,char*,F_INT*,F_INT*,<ctype6>*,<ctype6>*,F_INT*,<ctype6>*, &
-        <ctype6>*,F_INT*
-
-  integer optional, intent(in),check(lower==0||lower==1) :: lower = 0
-  integer optional,intent(in),check(trans>=0 && trans <=2) :: trans = 0
-
-  <ftype6> intent(in) :: alpha
-  <ftype6> intent(in),optional :: beta = <0.0,\0,(0.0\,0.0),\2,\2,\2>
-
-  <ftype6> dimension(lda,ka),intent(in) :: a
-  <ftype6> dimension(n,n),intent(in,out,copy),depend(n),optional :: c
-  check(shape(c,0)==n && shape(c,1)==n) :: c
-
-  integer depend(a),intent(hide) :: lda = shape(a,0)
-  integer depend(a),intent(hide) :: ka = shape(a,1)
-
-  integer depend(a, trans, ka, lda), intent(hide) :: n = (trans ? ka : lda)
-  integer depend(a, trans, ka, lda), intent(hide) :: k = (trans ? lda : ka)
-
-end subroutine <prefix6><sy,\0,\0,\0,he,he>rk
-
-
-!
-! LAPACK
-!
-
-subroutine <prefix>gesv(n,nrhs,a,piv,b,info)
-    ! lu,piv,x,info = gesv(a,b,overwrite_a=0,overwrite_b=0)
-    ! Solve A * X = B.
-    ! A = P * L * U
-    ! U is upper diagonal triangular, L is unit lower triangular,
-    ! piv pivots columns.
-
-    callstatement {F_INT i;(*f2py_func)(&n,&nrhs,a,&n,piv,b,&n,&info);for(i=0;i\<n;--piv[i++]);}
-    callprotoargument F_INT*,F_INT*,<ctype>*,F_INT*,F_INT*,<ctype>*,F_INT*,F_INT*
-
-    integer depend(a),intent(hide):: n = shape(a,0)
-    integer depend(b),intent(hide):: nrhs = shape(b,1)
-    <ftype> dimension(n,n),check(shape(a,0)==shape(a,1)) :: a
-    integer dimension(n),depend(n),intent(out) :: piv
-    <ftype> dimension(n,nrhs),check(shape(a,0)==shape(b,0)),depend(n) :: b
-    integer intent(out)::info
-    intent(in,out,copy,out=x) b
-    intent(in,out,copy,out=lu) a
-end subroutine <prefix>gesv
-
-
-subroutine <prefix2>gesdd(m,n,minmn,u0,u1,vt0,vt1,a,compute_uv,full_matrices,u,s,vt,work,lwork,iwork,info)
-    ! u,s,vt,info = gesdd(a,compute_uv=1,lwork=..,overwrite_a=0)
-    ! Compute the singular value decomposition (SVD) using divide and conquer:
-    !   A = U * SIGMA * transpose(V)
-    ! A - M x N matrix
-    ! U - M x M matrix or min(M,N) x N if full_matrices=False
-    ! SIGMA - M x N zero matrix with a main diagonal filled with min(M,N)
-    !               singular values
-    ! transpose(V) - N x N matrix or N x min(M,N) if full_matrices=False
-
-    callstatement (*f2py_func)((compute_uv?(full_matrices?"A":"S"):"N"),&m,&n,a,&m,s,u,&u0,vt,&vt0,work,&lwork,iwork,&info)
-    callprotoargument char*,F_INT*,F_INT*,<ctype2>*,F_INT*,<ctype2>*,<ctype2>*,F_INT*,<ctype2>*,F_INT*,<ctype2>*,F_INT*,F_INT*,F_INT*
-
-    integer intent(in),optional,check(compute_uv==0||compute_uv==1):: compute_uv = 1
-    integer intent(in),optional,check(full_matrices==0||full_matrices==1):: full_matrices = 1
-    integer intent(hide),depend(a):: m = shape(a,0)
-    integer intent(hide),depend(a):: n = shape(a,1)
-    integer intent(hide),depend(m,n):: minmn = MIN(m,n)
-    integer intent(hide),depend(compute_uv,minmn) :: u0 = (compute_uv?m:1)
-    integer intent(hide),depend(compute_uv,minmn, full_matrices) :: u1 = (compute_uv?(full_matrices?m:minmn):1)
-    integer intent(hide),depend(compute_uv,minmn, full_matrices) :: vt0 = (compute_uv?(full_matrices?n:minmn):1)
-    integer intent(hide),depend(compute_uv,minmn) :: vt1 = (compute_uv?n:1)
-    <ftype2> dimension(m,n),intent(in,copy,aligned8) :: a
-    <ftype2> dimension(minmn),intent(out),depend(minmn) :: s
-    <ftype2> dimension(u0,u1),intent(out),depend(u0, u1) :: u
-    <ftype2> dimension(vt0,vt1),intent(out),depend(vt0, vt1) :: vt
-    <ftype2> dimension(lwork),intent(hide,cache),depend(lwork) :: work
-    integer optional,intent(in),depend(minmn,compute_uv) &
-        :: lwork = max((compute_uv?4*minmn*minmn+MAX(m,n)+9*minmn:MAX(14*minmn+4,10*minmn+2+25*(25+8))+MAX(m,n)),1)
-    integer intent(hide,cache),dimension(8*minmn),depend(minmn) :: iwork
-    integer intent(out)::info
-
-end subroutine <prefix2>gesdd
-
-subroutine <prefix2>gesdd_lwork(m,n,minmn,u0,vt0,a,compute_uv,full_matrices,u,s,vt,work,lwork,iwork,info)
-    ! LWORK computation for (S/D)GESDD
-
-    fortranname <prefix2>gesdd
-    callstatement (*f2py_func)((compute_uv?(full_matrices?"A":"S"):"N"),&m,&n,&a,&m,&s,&u,&u0,&vt,&vt0,&work,&lwork,&iwork,&info)
-    callprotoargument char*,F_INT*,F_INT*,<ctype2>*,F_INT*,<ctype2>*,<ctype2>*,F_INT*,<ctype2>*,F_INT*,<ctype2>*,F_INT*,F_INT*,F_INT*
-
-    integer intent(in),optional,check(compute_uv==0||compute_uv==1):: compute_uv = 1
-    integer intent(in),optional,check(full_matrices==0||full_matrices==1):: full_matrices = 1
-    integer intent(in) :: m
-    integer intent(in) :: n
-    integer intent(hide),depend(m,n):: minmn = MIN(m,n)
-    integer intent(hide),depend(compute_uv,minmn) :: u0 = (compute_uv?m:1)
-    integer intent(hide),depend(compute_uv,minmn, full_matrices) :: vt0 = (compute_uv?(full_matrices?n:minmn):1)
-    <ftype2> intent(hide) :: a
-    <ftype2> intent(hide) :: s
-    <ftype2> intent(hide) :: u
-    <ftype2> intent(hide) :: vt
-    <ftype2> intent(out) :: work
-    integer intent(hide) :: lwork = -1
-    integer intent(hide) :: iwork
-    integer intent(out) :: info
-
-end subroutine <prefix2>gesdd_lwork
-
-
-subroutine <prefix2>syev(compute_v,lower,n,w,a,lda,work,lwork,info)
-    ! w,v,info = syev(a,compute_v=1,lower=0,lwork=3*n-1,overwrite_a=0)
-    ! Compute all eigenvalues and, optionally, eigenvectors of a
-    ! real symmetric matrix A.
-    !
-    ! Performance tip:
-    !   If compute_v=0 then set also overwrite_a=1.
-
-    callstatement (*f2py_func)((compute_v?"V":"N"),(lower?"L":"U"),&n,a,&lda,w,work,&lwork,&info)
-    callprotoargument char*,char*,F_INT*,<ctype2>*,F_INT*,<ctype2>*,<ctype2>*,F_INT*,F_INT*
-
-    integer optional,intent(in):: compute_v = 1
-    check(compute_v==1||compute_v==0) compute_v
-    integer optional,intent(in),check(lower==0||lower==1) :: lower = 0
-
-    integer intent(hide),depend(a):: n = shape(a,0)
-    integer intent(hide),depend(a):: lda = MAX(1,shape(a,0))
-    <ftype2> dimension(n,n),check(shape(a,0)==shape(a,1)) :: a
-    intent(in,copy,out,out=v) :: a
-
-    <ftype2> dimension(n),intent(out),depend(n) :: w
-
-    integer optional,intent(in),depend(n) :: lwork=max(3*n-1,1)
-    check(lwork>=3*n-1) :: lwork
-    <ftype2> dimension(lwork),intent(hide),depend(lwork) :: work
-
-    integer intent(out) :: info
-
-end subroutine <prefix2>syev
-
-
-subroutine <prefix2>syev_lwork(lower,n,w,a,lda,work,lwork,info)
-    ! LWORK routines for syev
-
-    fortranname <prefix2>syev
-
-    callstatement (*f2py_func)("N",(lower?"L":"U"),&n,&a,&lda,&w,&work,&lwork,&info)
-    callprotoargument char*,char*,F_INT*,<ctype2>*,F_INT*,<ctype2>*,<ctype2>*,F_INT*,F_INT*
-    
-     integer intent(in):: n
-     integer optional,intent(in),check(lower==0||lower==1) :: lower = 0
-     
-     integer intent(hide),depend(n):: lda = MAX(1, n)
-     <ftype2> intent(hide):: a
-     <ftype2> intent(hide):: w
-     integer intent(hide):: lwork = -1
-    
-     <ftype2> intent(out):: work
-     integer intent(out):: info
-     
-end subroutine <prefix2>syev_lwork
-
-end interface
-
-end python module _flapack
-
-
-

benchmark/pybench/openblas_wrap/generate_f2pymod.py

@@ -1,299 +0,0 @@
-#!/usr/bin/env python3
-"""
-Process f2py template files (`filename.pyf.src` -> `filename.pyf`)
-
-Usage: python generate_pyf.py filename.pyf.src -o filename.pyf
-"""
-
-import os
-import sys
-import re
-import subprocess
-import argparse
-
-
-# START OF CODE VENDORED FROM `numpy.distutils.from_template`
-#############################################################
-"""
-process_file(filename)
-
-  takes templated file .xxx.src and produces .xxx file where .xxx
-  is .pyf .f90 or .f using the following template rules:
-
-  '<..>' denotes a template.
-
-  All function and subroutine blocks in a source file with names that
-  contain '<..>' will be replicated according to the rules in '<..>'.
-
-  The number of comma-separated words in '<..>' will determine the number of
-  replicates.
-
-  '<..>' may have two different forms, named and short. For example,
-
-  named:
-   <p=d,s,z,c> where anywhere inside a block '<p>' will be replaced with
-   'd', 's', 'z', and 'c' for each replicate of the block.
-
-   <_c>  is already defined: <_c=s,d,c,z>
-   <_t>  is already defined: <_t=real,double precision,complex,double complex>
-
-  short:
-   <s,d,c,z>, a short form of the named, useful when no <p> appears inside
-   a block.
-
-  In general, '<..>' contains a comma separated list of arbitrary
-  expressions. If these expression must contain a comma|leftarrow|rightarrow,
-  then prepend the comma|leftarrow|rightarrow with a backslash.
-
-  If an expression matches '\\<index>' then it will be replaced
-  by <index>-th expression.
-
-  Note that all '<..>' forms in a block must have the same number of
-  comma-separated entries.
-
- Predefined named template rules:
-  <prefix=s,d,c,z>
-  <ftype=real,double precision,complex,double complex>
-  <ftypereal=real,double precision,\\0,\\1>
-  <ctype=float,double,complex_float,complex_double>
-  <ctypereal=float,double,\\0,\\1>
-"""
-
-routine_start_re = re.compile(
-    r'(\n|\A)((     (\$|\*))|)\s*(subroutine|function)\b',
-    re.I
-)
-routine_end_re = re.compile(r'\n\s*end\s*(subroutine|function)\b.*(\n|\Z)', re.I)
-function_start_re = re.compile(r'\n     (\$|\*)\s*function\b', re.I)
-
-def parse_structure(astr):
-    """ Return a list of tuples for each function or subroutine each
-    tuple is the start and end of a subroutine or function to be
-    expanded.
-    """
-
-    spanlist = []
-    ind = 0
-    while True:
-        m = routine_start_re.search(astr, ind)
-        if m is None:
-            break
-        start = m.start()
-        if function_start_re.match(astr, start, m.end()):
-            while True:
-                i = astr.rfind('\n', ind, start)
-                if i==-1:
-                    break
-                start = i
-                if astr[i:i+7]!='\n     $':
-                    break
-        start += 1
-        m = routine_end_re.search(astr, m.end())
-        ind = end = m and m.end()-1 or len(astr)
-        spanlist.append((start, end))
-    return spanlist
-
-template_re = re.compile(r"<\s*(\w[\w\d]*)\s*>")
-named_re = re.compile(r"<\s*(\w[\w\d]*)\s*=\s*(.*?)\s*>")
-list_re = re.compile(r"<\s*((.*?))\s*>")
-
-def find_repl_patterns(astr):
-    reps = named_re.findall(astr)
-    names = {}
-    for rep in reps:
-        name = rep[0].strip() or unique_key(names)
-        repl = rep[1].replace(r'\,', '@comma@')
-        thelist = conv(repl)
-        names[name] = thelist
-    return names
-
-def find_and_remove_repl_patterns(astr):
-    names = find_repl_patterns(astr)
-    astr = re.subn(named_re, '', astr)[0]
-    return astr, names
-
-item_re = re.compile(r"\A\\(?P<index>\d+)\Z")
-def conv(astr):
-    b = astr.split(',')
-    l = [x.strip() for x in b]
-    for i in range(len(l)):
-        m = item_re.match(l[i])
-        if m:
-            j = int(m.group('index'))
-            l[i] = l[j]
-    return ','.join(l)
-
-def unique_key(adict):
-    """ Obtain a unique key given a dictionary."""
-    allkeys = list(adict.keys())
-    done = False
-    n = 1
-    while not done:
-        newkey = '__l%s' % (n)
-        if newkey in allkeys:
-            n += 1
-        else:
-            done = True
-    return newkey
-
-
-template_name_re = re.compile(r'\A\s*(\w[\w\d]*)\s*\Z')
-def expand_sub(substr, names):
-    substr = substr.replace(r'\>', '@rightarrow@')
-    substr = substr.replace(r'\<', '@leftarrow@')
-    lnames = find_repl_patterns(substr)
-    substr = named_re.sub(r"<\1>", substr)  # get rid of definition templates
-
-    def listrepl(mobj):
-        thelist = conv(mobj.group(1).replace(r'\,', '@comma@'))
-        if template_name_re.match(thelist):
-            return "<%s>" % (thelist)
-        name = None
-        for key in lnames.keys():    # see if list is already in dictionary
-            if lnames[key] == thelist:
-                name = key
-        if name is None:      # this list is not in the dictionary yet
-            name = unique_key(lnames)
-            lnames[name] = thelist
-        return "<%s>" % name
-
-    substr = list_re.sub(listrepl, substr) # convert all lists to named templates
-                                           # newnames are constructed as needed
-
-    numsubs = None
-    base_rule = None
-    rules = {}
-    for r in template_re.findall(substr):
-        if r not in rules:
-            thelist = lnames.get(r, names.get(r, None))
-            if thelist is None:
-                raise ValueError('No replicates found for <%s>' % (r))
-            if r not in names and not thelist.startswith('_'):
-                names[r] = thelist
-            rule = [i.replace('@comma@', ',') for i in thelist.split(',')]
-            num = len(rule)
-
-            if numsubs is None:
-                numsubs = num
-                rules[r] = rule
-                base_rule = r
-            elif num == numsubs:
-                rules[r] = rule
-            else:
-                print("Mismatch in number of replacements (base <{}={}>) "
-                      "for <{}={}>. Ignoring."
-                      .format(base_rule, ','.join(rules[base_rule]), r, thelist))
-    if not rules:
-        return substr
-
-    def namerepl(mobj):
-        name = mobj.group(1)
-        return rules.get(name, (k+1)*[name])[k]
-
-    newstr = ''
-    for k in range(numsubs):
-        newstr += template_re.sub(namerepl, substr) + '\n\n'
-
-    newstr = newstr.replace('@rightarrow@', '>')
-    newstr = newstr.replace('@leftarrow@', '<')
-    return newstr
-
-def process_str(allstr):
-    newstr = allstr
-    writestr = ''
-
-    struct = parse_structure(newstr)
-
-    oldend = 0
-    names = {}
-    names.update(_special_names)
-    for sub in struct:
-        cleanedstr, defs = find_and_remove_repl_patterns(newstr[oldend:sub[0]])
-        writestr += cleanedstr
-        names.update(defs)
-        writestr += expand_sub(newstr[sub[0]:sub[1]], names)
-        oldend =  sub[1]
-    writestr += newstr[oldend:]
-
-    return writestr
-
-include_src_re = re.compile(
-    r"(\n|\A)\s*include\s*['\"](?P<name>[\w\d./\\]+\.src)['\"]",
-    re.I
-)
-
-def resolve_includes(source):
-    d = os.path.dirname(source)
-    with open(source) as fid:
-        lines = []
-        for line in fid:
-            m = include_src_re.match(line)
-            if m:
-                fn = m.group('name')
-                if not os.path.isabs(fn):
-                    fn = os.path.join(d, fn)
-                if os.path.isfile(fn):
-                    lines.extend(resolve_includes(fn))
-                else:
-                    lines.append(line)
-            else:
-                lines.append(line)
-    return lines
-
-def process_file(source):
-    lines = resolve_includes(source)
-    return process_str(''.join(lines))
-
-_special_names = find_repl_patterns('''
-<_c=s,d,c,z>
-<_t=real,double precision,complex,double complex>
-<prefix=s,d,c,z>
-<ftype=real,double precision,complex,double complex>
-<ctype=float,double,complex_float,complex_double>
-<ftypereal=real,double precision,\\0,\\1>
-<ctypereal=float,double,\\0,\\1>
-''')
-
-# END OF CODE VENDORED FROM `numpy.distutils.from_template`
-###########################################################
-
-
-def main():
-    parser = argparse.ArgumentParser()
-    parser.add_argument("infile", type=str,
-                        help="Path to the input file")
-    parser.add_argument("-o", "--outdir", type=str,
-                        help="Path to the output directory")
-    args = parser.parse_args()
-
-    if not args.infile.endswith(('.pyf', '.pyf.src', '.f.src')):
-        raise ValueError(f"Input file has unknown extension: {args.infile}")
-
-    outdir_abs = os.path.join(os.getcwd(), args.outdir)
-
-    # Write out the .pyf/.f file
-    if args.infile.endswith(('.pyf.src', '.f.src')):
-        code = process_file(args.infile)
-        fname_pyf = os.path.join(args.outdir,
-                                 os.path.splitext(os.path.split(args.infile)[1])[0])
-
-        with open(fname_pyf, 'w') as f:
-            f.write(code)
-    else:
-        fname_pyf = args.infile
-
-    # Now invoke f2py to generate the C API module file
-    if args.infile.endswith(('.pyf.src', '.pyf')):
-        p = subprocess.Popen([sys.executable, '-m', 'numpy.f2py', fname_pyf,
-                            '--build-dir', outdir_abs], #'--quiet'],
-                            stdout=subprocess.PIPE, stderr=subprocess.PIPE,
-                            cwd=os.getcwd())
-        out, err = p.communicate()
-        if not (p.returncode == 0):
-            raise RuntimeError(f"Writing {args.outfile} with f2py failed!\n"
-                            f"{out}\n"
-                            r"{err}")
-
-
-if __name__ == "__main__":
-    main()

benchmark/pybench/openblas_wrap/meson.build

@@ -1,50 +0,0 @@
-# find numpy & f2py includes
-inc_numpy = run_command(py3,
-  ['-c', 'import os; os.chdir(".."); import numpy; print(numpy.get_include())'],
-  check : true
-).stdout().strip()
-
-inc_f2py = run_command(py3,
-    ['-c', 'import os; os.chdir(".."); import numpy.f2py; print(numpy.f2py.get_include())'],
-    check : true
-).stdout().strip()
-
-
-inc_np = include_directories(inc_numpy, inc_f2py)
-fortranobject_c = inc_f2py / 'fortranobject.c'
-
-
-fortranobject_lib = static_library('_fortranobject',
-  fortranobject_c,
-#  c_args: numpy_nodepr_api,
-  dependencies: py3_dep,
-  include_directories: [inc_np, inc_f2py],
-  gnu_symbol_visibility: 'hidden',
-)
-fortranobject_dep = declare_dependency(
-  link_with: fortranobject_lib,
-  include_directories: [inc_np, inc_f2py],
-)
-
-
-# f2py generated wrappers
-
-flapack_module = custom_target('flapack_module',
-  output: ['_flapackmodule.c'],
-  input: 'blas_lapack.pyf.src',
-  command: [generate_f2pymod, '@INPUT@', '-o', '@OUTDIR@'],
-)
-
-py3.extension_module('_flapack',
-  flapack_module,
-  link_args: [],  # version_link_args,
-  dependencies: [openblas_dep, fortranobject_dep],
-  install: true,
-  subdir: 'openblas_wrap'
-)
-
-
-py3.install_sources(
-  ['__init__.py'],
-  subdir: 'openblas_wrap'
-)

benchmark/pybench/scipy_openblas.pc

@@ -1,12 +0,0 @@
-libdir=/home/br/repos/OpenBLAS/
-includedir=/home/br/repos/OpenBLAS/
-openblas_config= OpenBLAS 0.3.27 DYNAMIC_ARCH NO_AFFINITY Haswell MAX_THREADS=64
-version=0.3.27
-extralib=-lm -lpthread -lgfortran -lquadmath -L${libdir} -lopenblas
-Name: openblas
-Description: OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version
-Version: ${version}
-URL: https://github.com/xianyi/OpenBLAS
-Libs: -L${libdir} -lopenblas
-Libs.private: ${extralib}
-Cflags: -I${includedir}

benchmark/rotm.c

@@ -1,138 +1,138 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef ROTM
-
-#ifdef DOUBLE
-#define ROTM BLASFUNC(drotm)
-#else
-#define ROTM BLASFUNC(srotm)
-#endif
-
-int main(int argc, char *argv[])
-{
-
-    FLOAT *x, *y;
-    // FLOAT result;
-    blasint m, i;
-    blasint inc_x = 1, inc_y = 1;
-    FLOAT param[5] = {1, 2.0, 3.0, 4.0, 5.0};
-    int loops = 1;
-    int l;
-    char *p;
-
-    int from = 1;
-    int to = 200;
-    int step = 1;
-
-    
-    double time1, timeg;
-
-    argc--;
-    argv++;
-
-    if (argc > 0) {
-        from = atol(*argv);
-        argc--;
-        argv++;
-    }
-    if (argc > 0) {
-        to = MAX(atol(*argv), from);
-        argc--;
-        argv++;
-    }
-    if (argc > 0) {
-        step = atol(*argv);
-        argc--;
-        argv++;
-    }
-
-    if ((p = getenv("OPENBLAS_LOOPS")))
-        loops = atoi(p);
-    if ((p = getenv("OPENBLAS_INCX")))
-        inc_x = atoi(p);
-    if ((p = getenv("OPENBLAS_INCY")))
-        inc_y = atoi(p);
-
-    fprintf(
-        stderr,
-        "From : %3d  To : %3d Step = %3d Inc_x = %d Inc_y = %d Loops = %d\n",
-        from, to, step, inc_x, inc_y, loops);
-
-    if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) ==
-        NULL) {
-        fprintf(stderr, "Out of Memory!!\n");
-        exit(1);
-    }
-
-    if ((y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) ==
-        NULL) {
-        fprintf(stderr, "Out of Memory!!\n");
-        exit(1);
-    }
-
-#ifdef __linux
-    srandom(getpid());
-#endif
-
-    fprintf(stderr, "   SIZE       Flops\n");
-
-    for (m = from; m <= to; m += step) {
-
-        timeg = 0;
-
-        fprintf(stderr, " %6d : ", (int)m);
-        for (i = 0; i < m * COMPSIZE * abs(inc_x); i++) {
-            x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
-        }
-
-        for (i = 0; i < m * COMPSIZE * abs(inc_y); i++) {
-            y[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
-        }
-
-        for (l = 0; l < loops; l++) {
-            begin();
-
-            ROTM(&m, x, &inc_x, y, &inc_y, param);
-
-            end();
-
-            time1 = getsec();
-
-            timeg += time1;
-        }
-
-        timeg /= loops;
-
-        fprintf(stderr, " %10.2f MFlops %10.6f sec\n",
-                COMPSIZE * COMPSIZE * 6. * (double)m / timeg * 1.e-6, timeg);
-    }
-
-    return 0;
-}
+/***************************************************************************
+Copyright (c) 2014, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef ROTM
+
+#ifdef DOUBLE
+#define ROTM BLASFUNC(drotm)
+#else
+#define ROTM BLASFUNC(srotm)
+#endif
+
+int main(int argc, char *argv[])
+{
+
+    FLOAT *x, *y;
+    // FLOAT result;
+    blasint m, i;
+    blasint inc_x = 1, inc_y = 1;
+    FLOAT param[5] = {1, 2.0, 3.0, 4.0, 5.0};
+    int loops = 1;
+    int l;
+    char *p;
+
+    int from = 1;
+    int to = 200;
+    int step = 1;
+
+    
+    double time1, timeg;
+
+    argc--;
+    argv++;
+
+    if (argc > 0) {
+        from = atol(*argv);
+        argc--;
+        argv++;
+    }
+    if (argc > 0) {
+        to = MAX(atol(*argv), from);
+        argc--;
+        argv++;
+    }
+    if (argc > 0) {
+        step = atol(*argv);
+        argc--;
+        argv++;
+    }
+
+    if ((p = getenv("OPENBLAS_LOOPS")))
+        loops = atoi(p);
+    if ((p = getenv("OPENBLAS_INCX")))
+        inc_x = atoi(p);
+    if ((p = getenv("OPENBLAS_INCY")))
+        inc_y = atoi(p);
+
+    fprintf(
+        stderr,
+        "From : %3d  To : %3d Step = %3d Inc_x = %d Inc_y = %d Loops = %d\n",
+        from, to, step, inc_x, inc_y, loops);
+
+    if ((x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) ==
+        NULL) {
+        fprintf(stderr, "Out of Memory!!\n");
+        exit(1);
+    }
+
+    if ((y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) ==
+        NULL) {
+        fprintf(stderr, "Out of Memory!!\n");
+        exit(1);
+    }
+
+#ifdef __linux
+    srandom(getpid());
+#endif
+
+    fprintf(stderr, "   SIZE       Flops\n");
+
+    for (m = from; m <= to; m += step) {
+
+        timeg = 0;
+
+        fprintf(stderr, " %6d : ", (int)m);
+        for (i = 0; i < m * COMPSIZE * abs(inc_x); i++) {
+            x[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
+        }
+
+        for (i = 0; i < m * COMPSIZE * abs(inc_y); i++) {
+            y[i] = ((FLOAT)rand() / (FLOAT)RAND_MAX) - 0.5;
+        }
+
+        for (l = 0; l < loops; l++) {
+            begin();
+
+            ROTM(&m, x, &inc_x, y, &inc_y, param);
+
+            end();
+
+            time1 = getsec();
+
+            timeg += time1;
+        }
+
+        timeg /= loops;
+
+        fprintf(stderr, " %10.2f MFlops %10.6f sec\n",
+                COMPSIZE * COMPSIZE * 6. * (double)m / timeg * 1.e-6, timeg);
+    }
+
+    return 0;
+}

benchmark/scal.c

@@ -45,7 +45,7 @@ USE OF THIS SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
 
 int main(int argc, char *argv[]){
 
-  FLOAT *x;
+  FLOAT *x, *y;
   FLOAT alpha[2] = { 2.0, 2.0 };
   blasint m, i;
   blasint inc_x=1,inc_y=1;
@@ -74,6 +74,10 @@ int main(int argc, char *argv[]){
     fprintf(stderr,"Out of Memory!!\n");exit(1);
   }
 
+  if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
+  }
+
 #ifdef __linux
   srandom(getpid());
 #endif
@@ -87,20 +91,30 @@ int main(int argc, char *argv[]){
 
    fprintf(stderr, " %6d : ", (int)m);
 
-   for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-	x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   }
 
-   begin();
    for (l=0; l<loops; l++)
    {
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
+			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+    	begin();
+
     	SCAL (&m, alpha, x, &inc_x);
-   }
-   end();
 
-   time1 = getsec();
+    	end();
 
-   timeg = time1 / loops;
+    	time1 = getsec();
+
+	timeg += time1;
+
+    }
+
+    timeg /= loops;
 
 #ifdef COMPLEX
     fprintf(stderr, " %10.2f MFlops %10.6f sec\n", 6. * (double)m / timeg * 1.e-6, timeg);

benchmark/spmv.c

@@ -1,146 +1,146 @@
-/***************************************************************************
-Copyright (c) 2014, The OpenBLAS Project
-All rights reserved.
-Redistribution and use in source and binary forms, with or without
-modification, are permitted provided that the following conditions are
-met:
-1. Redistributions of source code must retain the above copyright
-notice, this list of conditions and the following disclaimer.
-2. 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.
-3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-*****************************************************************************/
-
-#include "bench.h"
-
-#undef SPMV
-
-#ifndef COMPLEX
-
-#ifdef DOUBLE
-#define SPMV   BLASFUNC(dspmv)
-#else
-#define SPMV   BLASFUNC(sspmv)
-#endif
-
-#else
-
-#ifdef DOUBLE
-#define SPMV   BLASFUNC(zspmv)
-#else
-#define SPMV   BLASFUNC(cspmv)
-#endif
-
-#endif
-
-int main(int argc, char *argv[]){
-
-  FLOAT *a, *x, *y;
-  FLOAT alpha[] = {1.0, 1.0};
-  FLOAT beta [] = {1.0, 1.0};
-  char uplo='L';
-  blasint m, i, j;
-  blasint inc_x=1,inc_y=1;
-  int loops = 1;
-  int l;
-  char *p;
-
-  int from =   1;
-  int to   = 200;
-  int step =   1;
-
-  double time1,timeg;
-
-  argc--;argv++;
-
-  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
-  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
-  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
-
-  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
-  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
-  if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
-  if ((p = getenv("OPENBLAS_UPLO")))  uplo=*p;
-
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = '%c' Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,uplo,inc_x,inc_y,loops);
-
-  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-  if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL){
-    fprintf(stderr,"Out of Memory!!\n");exit(1);
-  }
-
-#ifdef __linux
-  srandom(getpid());
-#endif
-
-  fprintf(stderr, "   SIZE       Flops\n");
-
-  for(m = from; m <= to; m += step)
-  {
-
-   timeg=0;
-
-   fprintf(stderr, " %6dx%d : ", (int)m,(int)m);
-
-   for(j = 0; j < m; j++){
-      		for(i = 0; i < m * COMPSIZE; i++){
-			a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-      		}
-   }
-
-
-    for (l=0; l<loops; l++)
-    {
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
-			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-
-   	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
-			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
-   	}
-    	begin();
-
-    	SPMV (&uplo, &m, alpha, a, x, &inc_x, beta, y, &inc_y );
-
-    	end();
-
-    	time1 = getsec();
-
-	timeg += time1;
-
-    }
-
-    timeg /= loops;
-
-    fprintf(stderr,
-	    " %10.2f MFlops\n",
-	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)m / timeg * 1.e-6);
-
-  }
-
-  return 0;
-}
-
-// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));
+/***************************************************************************
+Copyright (c) 2014, The OpenBLAS Project
+All rights reserved.
+Redistribution and use in source and binary forms, with or without
+modification, are permitted provided that the following conditions are
+met:
+1. Redistributions of source code must retain the above copyright
+notice, this list of conditions and the following disclaimer.
+2. 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.
+3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
+ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
+*****************************************************************************/
+
+#include "bench.h"
+
+#undef SPMV
+
+#ifndef COMPLEX
+
+#ifdef DOUBLE
+#define SPMV   BLASFUNC(dspmv)
+#else
+#define SPMV   BLASFUNC(sspmv)
+#endif
+
+#else
+
+#ifdef DOUBLE
+#define SPMV   BLASFUNC(zspmv)
+#else
+#define SPMV   BLASFUNC(cspmv)
+#endif
+
+#endif
+
+int main(int argc, char *argv[]){
+
+  FLOAT *a, *x, *y;
+  FLOAT alpha[] = {1.0, 1.0};
+  FLOAT beta [] = {1.0, 1.0};
+  char uplo='L';
+  blasint m, i, j;
+  blasint inc_x=1,inc_y=1;
+  int loops = 1;
+  int l;
+  char *p;
+
+  int from =   1;
+  int to   = 200;
+  int step =   1;
+
+  double time1,timeg;
+
+  argc--;argv++;
+
+  if (argc > 0) { from     = atol(*argv);		argc--; argv++;}
+  if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
+  if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
+
+  if ((p = getenv("OPENBLAS_LOOPS")))  loops = atoi(p);
+  if ((p = getenv("OPENBLAS_INCX")))   inc_x = atoi(p);
+  if ((p = getenv("OPENBLAS_INCY")))   inc_y = atoi(p);
+  if ((p = getenv("OPENBLAS_UPLO")))  uplo=*p;
+
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = '%c' Inc_x = %d Inc_y = %d Loops = %d\n", from, to, step,uplo,inc_x,inc_y,loops);
+
+  if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
+  }
+
+  if (( x = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_x) * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
+  }
+
+  if (( y = (FLOAT *)malloc(sizeof(FLOAT) * to * abs(inc_y) * COMPSIZE)) == NULL){
+    fprintf(stderr,"Out of Memory!!\n");exit(1);
+  }
+
+#ifdef __linux
+  srandom(getpid());
+#endif
+
+  fprintf(stderr, "   SIZE       Flops\n");
+
+  for(m = from; m <= to; m += step)
+  {
+
+   timeg=0;
+
+   fprintf(stderr, " %6dx%d : ", (int)m,(int)m);
+
+   for(j = 0; j < m; j++){
+      		for(i = 0; i < m * COMPSIZE; i++){
+			a[(long)i + (long)j * (long)m * COMPSIZE] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+      		}
+   }
+
+
+    for (l=0; l<loops; l++)
+    {
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_x); i++){
+			x[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+
+   	for(i = 0; i < m * COMPSIZE * abs(inc_y); i++){
+			y[i] = ((FLOAT) rand() / (FLOAT) RAND_MAX) - 0.5;
+   	}
+    	begin();
+
+    	SPMV (&uplo, &m, alpha, a, x, &inc_x, beta, y, &inc_y );
+
+    	end();
+
+    	time1 = getsec();
+
+	timeg += time1;
+
+    }
+
+    timeg /= loops;
+
+    fprintf(stderr,
+	    " %10.2f MFlops\n",
+	    COMPSIZE * COMPSIZE * 2. * (double)m * (double)m / timeg * 1.e-6);
+
+  }
+
+  return 0;
+}
+
+// void main(int argc, char *argv[]) __attribute__((weak, alias("MAIN__")));

benchmark/syr2.c

@@ -54,7 +54,7 @@ int main(int argc, char *argv[]){
   int step =   1;
   int loops =  1;
 
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=atoi(p);
+  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
 
   double time1,timeg;
 

benchmark/syrk.c

@@ -1,5 +1,5 @@
 /***************************************************************************
-Copyright (c) 2014, 2023 The OpenBLAS Project
+Copyright (c) 2014, The OpenBLAS Project
 All rights reserved.
 Redistribution and use in source and binary forms, with or without
 modification, are permitted provided that the following conditions are
@@ -67,7 +67,7 @@ int main(int argc, char *argv[]){
   int step =   1;
   int loops =  1;
 
-  if ((p = getenv("OPENBLAS_LOOPS"))) loops=atoi(p);
+  if ((p = getenv("OPENBLAS_LOOPS"))) loops=*p;
 
   double time1,timeg;
 
@@ -77,7 +77,7 @@ int main(int argc, char *argv[]){
   if (argc > 0) { to       = MAX(atol(*argv), from);	argc--; argv++;}
   if (argc > 0) { step     = atol(*argv);		argc--; argv++;}
 
-  fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Trans = %c Loops = %d\n", from, to, step,uplo,trans,loops);
+  fprintf(stderr, "From : %3d  To : %3d Step = %3d Uplo = %c Trans = %c\n", from, to, step,uplo,trans);
 
 
   if (( a = (FLOAT *)malloc(sizeof(FLOAT) * to * to * COMPSIZE)) == NULL){

benchmark/trsv.c

@@ -127,7 +127,7 @@ int main(int argc, char *argv[]){
       long long muls = n*(n+1)/2.0;
       long long adds = (n - 1.0)*n/2.0;
 
-      fprintf(stderr, "%10d :   %10.2f MFlops %10.6f sec\n", n,(muls+adds) / timeg * 1.e-6, timeg);
+      fprintf(stderr, "%10d   %10.2f MFlops %10.6f sec\n", n,(muls+adds) / timeg * 1.e-6, timeg);
       if(a != NULL){
         free(a);
       }

c_check

@@ -1,550 +1,419 @@
-#!/bin/sh
+#!/usr/bin/env perl
+
+#use File::Basename;
+# use File::Temp qw(tempfile);
 
 # Checking cross compile
-hostos=`uname -s | sed -e 's/\-.*//'`
-hostarch=`uname -m | sed -e 's/i.86/x86/'`
-if [ "$hostos" = "AIX" ] || [ "$hostos" = "SunOS" ]; then
-    hostarch=`uname -p`
-fi
-if [ "$hostarch" = "evbarm" ]; then
-    hostarch=`uname -p`
-fi
-case "$hostarch" in
-    amd64) hostarch=x86_64 ;;
-    arm*) [ "$hostarch" = "arm64" ] || hostarch='arm' ;;
-    aarch64) hostarch=arm64 ;;
-    powerpc*|ppc*) hostarch=power ;;
-    s390x) hostarch=zarch ;;
-esac
+$hostos   = `uname -s | sed -e s/\-.*//`;    chop($hostos);
+$hostarch = `uname -m | sed -e s/i.86/x86/`;
+$hostarch = `uname -p` if ($hostos eq "AIX" || $hostos eq "SunOS");
+chop($hostarch);
+$hostarch = "x86_64" if ($hostarch eq "amd64");
+$hostarch = "arm" if ($hostarch ne "arm64" && $hostarch =~ /^arm.*/);
+$hostarch = "arm64" if ($hostarch eq "aarch64");
+$hostarch = "power" if ($hostarch =~ /^(powerpc|ppc).*/);
+$hostarch = "zarch" if ($hostarch eq "s390x");
 
-makefile="$1"
-config="$2"
+#$tmpf = new File::Temp( UNLINK => 1 );
+$binary = $ENV{"BINARY"};
 
-compiler_name="$3"
-shift 3
-flags="$*"
-darwin_os=""
+$makefile = shift(@ARGV);
+$config   = shift(@ARGV);
+
+$compiler_name = shift(@ARGV);
+$flags = join(" ", @ARGV);
 
 # First, we need to know the target OS and compiler name
-{
-    data=`$compiler_name $flags -E ctest.c`
-} || {
-    printf '%s\n' "C Compiler ($compiler_name) is something wrong." >&2
-    exit 1
+
+$data = `$compiler_name $flags -E ctest.c`;
+
+if ($?) {
+    printf STDERR "C Compiler ($compiler_name) is something wrong.\n";
+    die 1;
 }
 
-cross_suffix=""
+$cross_suffix = "";
 
-if [ "`dirname "$compiler_name"`" != '.' ]; then
-    cross_suffix="$cross_suffix`dirname "$compiler_name"`/"
-fi
+eval "use File::Basename";
+if ($@){ 
+    warn "could not load PERL module File::Basename, emulating its functionality";
+    my $dirnam = substr($compiler_name, 0, rindex($compiler_name, "/")-1 );
+    if ($dirnam ne ".") {
+	$cross_suffix .= $dirnam . "/";
+    }
+    my $basnam = substr($compiler_name, rindex($compiler_name,"/")+1, length($compiler_name)-rindex($compiler_name,"/")-1);
+	if ($basnam =~ /([^\s]*-)(.*)/) {
+	$cross_suffix .= $1;
+    }
+} else {
+    if (dirname($compiler_name) ne ".") {
+	$cross_suffix .= dirname($compiler_name) . "/";
+    }
 
-cn=`echo $compiler_name | sed -e 's/ -.*//'`
-bn=`basename "$cn"`
+    if (basename($compiler_name) =~ /([^\s]*-)(.*)/) {
+	$cross_suffix .= $1;
+    }
+}
 
-case "$bn" in
-    *-*) if [ "$bn" != '-' ]; then
-           cross_suffix="$cross_suffix${bn%-*}-"
-         fi
-esac
+$compiler = "";
+$compiler = LSB       if ($data =~ /COMPILER_LSB/);
+$compiler = CLANG     if ($data =~ /COMPILER_CLANG/);
+$compiler = PGI       if ($data =~ /COMPILER_PGI/);
+$compiler = PATHSCALE if ($data =~ /COMPILER_PATHSCALE/);
+$compiler = INTEL     if ($data =~ /COMPILER_INTEL/);
+$compiler = OPEN64    if ($data =~ /COMPILER_OPEN64/);
+$compiler = SUN       if ($data =~ /COMPILER_SUN/);
+$compiler = IBM       if ($data =~ /COMPILER_IBM/);
+$compiler = DEC       if ($data =~ /COMPILER_DEC/);
+$compiler = GCC       if ($compiler eq "");
 
-compiler=""
-case "$data" in
-    *COMPILER_LSB*) compiler=LSB ;;
-    *COMPILER_CLANG*) compiler=CLANG ;;
-    *COMPILER_PGI*) compiler=PGI ;;
-    *COMPILER_PATHSCALE*) compiler=PATHSCALE ;;
-    *COMPILER_INTEL*) compiler=INTEL ;;
-    *COMPILER_OPEN64*) compiler=OPEN64 ;;
-    *COMPILER_SUN*) compiler=SUN ;;
-    *COMPILER_IBM*) compiler=IBM ;;
-    *COMPILER_DEC*) compiler=DEC ;;
-    *COMPILER_FUJITSU*) compiler=FUJITSU ;;
-esac
-if [ -z "$compiler" ]; then
-    compiler=GCC
-fi
+$os = Linux           if ($data =~ /OS_LINUX/);
+$os = FreeBSD         if ($data =~ /OS_FREEBSD/);
+$os = NetBSD          if ($data =~ /OS_NETBSD/);
+$os = OpenBSD         if ($data =~ /OS_OPENBSD/);
+$os = DragonFly       if ($data =~ /OS_DRAGONFLY/);
+$os = Darwin          if ($data =~ /OS_DARWIN/);
+$os = SunOS           if ($data =~ /OS_SUNOS/);
+$os = AIX             if ($data =~ /OS_AIX/);
+$os = osf             if ($data =~ /OS_OSF/);
+$os = WINNT           if ($data =~ /OS_WINNT/);
+$os = CYGWIN_NT       if ($data =~ /OS_CYGWIN_NT/);
+$os = Interix         if ($data =~ /OS_INTERIX/);
+$os = Android         if ($data =~ /OS_ANDROID/);
+$os = Haiku           if ($data =~ /OS_HAIKU/);
 
-case "$data" in *OS_LINUX*) os=Linux ;; esac
-case "$data" in *OS_FREEBSD*) os=FreeBSD ;; esac
-case "$data" in *OS_NETBSD*) os=NetBSD ;; esac
-case "$data" in *OS_OPENBSD*) os=OpenBSD ;; esac
-case "$data" in *OS_DRAGONFLY*) os=DragonFly ;; esac
-case "$data" in *OS_DARWIN*) os=Darwin; darwin_os=macOS ;; esac
-case "$data" in *OS_SUNOS*) os=SunOS ;; esac
-case "$data" in *OS_AIX*) os=AIX ;; esac
-case "$data" in *OS_OSF*) os=osf ;; esac
-case "$data" in *OS_WINNT*) os=WINNT ;; esac
-case "$data" in *OS_CYGWIN_NT*) os=CYGWIN_NT ;; esac
-case "$data" in *OS_INTERIX*) os=Interix ;; esac
-case "$data" in *OS_ANDROID*) os=Android ;; esac
-case "$data" in *OS_HAIKU*) os=Haiku ;; esac
-case "$data" in *OS_IOS*) darwin_os=iOS ;; esac
+$architecture = x86          if ($data =~ /ARCH_X86/);
+$architecture = x86_64       if ($data =~ /ARCH_X86_64/);
+$architecture = power        if ($data =~ /ARCH_POWER/);
+$architecture = mips         if ($data =~ /ARCH_MIPS/);
+$architecture = mips64       if ($data =~ /ARCH_MIPS64/);
+$architecture = alpha        if ($data =~ /ARCH_ALPHA/);
+$architecture = sparc        if ($data =~ /ARCH_SPARC/);
+$architecture = ia64         if ($data =~ /ARCH_IA64/);
+$architecture = arm          if ($data =~ /ARCH_ARM/);
+$architecture = arm64        if ($data =~ /ARCH_ARM64/);
+$architecture = zarch        if ($data =~ /ARCH_ZARCH/);
+$architecture = riscv64      if ($data =~ /ARCH_RISCV64/);
+$architecture = loongarch64  if ($data =~ /ARCH_LOONGARCH64/);
 
-case "$data" in
-    *ARCH_X86_64*) architecture=x86_64 ;;
-    *ARCH_X86*) architecture=x86 ;;
-    *ARCH_E2K*) architecture=e2k ;;
-    *ARCH_POWER*) architecture=power ;;
-    *ARCH_MIPS64*) architecture=mips64 ;;
-    *ARCH_MIPS*) architecture=mips ;;
-    *ARCH_ALPHA*) architecture=alpha ;;
-    *ARCH_SPARC*) architecture=sparc ;;
-    *ARCH_IA64*) architecture=ia64 ;;
-    *ARCH_ARM64*) architecture=arm64 ;;
-    *ARCH_ARM*) architecture=arm ;;
-    *ARCH_ZARCH*) architecture=zarch ;;
-    *ARCH_RISCV64*) architecture=riscv64 ;;
-    *ARCH_LOONGARCH64*) architecture=loongarch64 ;;
-    *ARCH_CSKY*) architecture=csky ;;
-    *ARCH_WASM*) architecture=wasm ;;
-esac
+$defined = 0;
 
-defined=0
+if ($os eq "AIX") {
+    $compiler_name .= " -maix32" if ($binary eq "32");
+    $compiler_name .= " -maix64" if ($binary eq "64");
+    $defined = 1;
+}
 
-if [ "$os" = "AIX" ]; then
-    if [ "$compiler" = "GCC" ]; then
-        case "$BINARY" in
-            32) compiler_name="$compiler_name -maix32" ;;
-            64) compiler_name="$compiler_name -maix64" ;;
-        esac
-        defined=1
-    else
-        case "$BINARY" in
-            32) compiler_name="$compiler_name -m32" ;;
-            64) compiler_name="$compiler_name -m64" ;;
-        esac
-        defined=1
-    fi
-fi
+if ($architecture eq "mips") {
+    $compiler_name .= " -mabi=32";
+    $defined = 1;
+}
 
-case "$architecture" in
-    mips)
-    	compiler_name="$compiler_name -mabi=32"
-    	defined=1
-    	;;
-    mips64)
-    	case "$BINARY" in
-    	    32) compiler_name="$compiler_name -mabi=n32" ;;
-    	    64) compiler_name="$compiler_name -mabi=64" ;;
-    	esac
-    	defined=1
-    	;;
-    arm|arm64) defined=1 ;;
-    zarch|e2k|alpha|ia64|riscv64|loongarch64|wasm)
-    	defined=1
-    	BINARY=64
-    	;;
-    x86)
-    	[ "$os" != "Darwin" ] && [ "$os" != "SunOS" ] && {
-    	    defined=1
-    	    BINARY=32
-    	}
-    	;;
-esac
+if ($architecture eq "mips64") {
+    $compiler_name .= " -mabi=n32" if ($binary eq "32");
+    $compiler_name .= " -mabi=64" if ($binary eq "64");
+    $defined = 1;
+}
 
-case "$compiler" in
-    PGI)
-    	case "$BINARY" in
-    	    32) compiler_name="$compiler_name -tp p7" ;;
-    	    64) compiler_name="$compiler_name -tp p7-64" ;;
-    	esac
-    	openmp='-mp'
-    	defined=1
-    	;;
-    IBM)
-    	case "$BINARY" in
-    	    32) compiler_name="$compiler_name -q32" ;;
-    	    64) compiler_name="$compiler_name -q64" ;;
-    	esac
-    	openmp='-qsmp=omp'
-    	defined=1
-    	;;
-    INTEL) openmp='-openmp' ;;
-    PATHSCALE|OPEN64) openmp='-mp' ;;
-    CLANG|GCC|LSB) openmp='-fopenmp' ;;
-    FUJITSU) openmp='-Kopenmp' ;;
-esac
+if (($architecture eq "arm") || ($architecture eq "arm64")) {
+    $defined = 1;
+}
 
-if [ "$defined" -eq 0 ]; then
-    case "$BINARY" in
-    	32) compiler_name="$compiler_name -m32" ;;
-    	64) compiler_name="$compiler_name -m64" ;;
-    esac
-fi
+if ($architecture eq "zarch") {
+    $defined = 1;
+    $binary = 64;
+}
+
+if ($architecture eq "alpha") {
+    $defined = 1;
+    $binary = 64;
+}
+
+if ($architecture eq "ia64") {
+    $defined = 1;
+    $binary = 64;
+}
+
+if (($architecture eq "x86") && ($os ne Darwin) && ($os ne SunOS)) {
+    $defined = 1;
+    $binary =32;
+}
+
+if ($architecture eq "riscv64") {
+    $defined = 1;
+    $binary = 64;
+}
+
+if ($architecture eq "loongarch64") {
+    $defined = 1;
+    $binary = 64;
+}
+
+if ($compiler eq "PGI") {
+    $compiler_name .= " -tp p7"    if ($binary eq "32");
+    $compiler_name .= " -tp p7-64" if ($binary eq "64");
+    $openmp = "-mp";
+    $defined = 1;
+}
+
+if ($compiler eq "IBM") {
+    $compiler_name .= " -q32"  if ($binary eq "32");
+    $compiler_name .= " -q64"  if ($binary eq "64");
+    $openmp = "-qsmp=omp";
+    $defined = 1;
+}
+
+if ($compiler eq "INTEL") {
+    $openmp = "-openmp";
+}
+
+if ($compiler eq "PATHSCALE") {
+    $openmp = "-mp";
+}
+
+if ($compiler eq "OPEN64") {
+    $openmp = "-mp";
+}
+
+if ($compiler eq "CLANG") {
+    $openmp = "-fopenmp";
+}
+
+if ($compiler eq "GCC" || $compiler eq "LSB") {
+    $openmp = "-fopenmp";
+}
+
+if ($defined == 0) {
+    $compiler_name .= " -m32" if ($binary eq "32");
+    $compiler_name .= " -m64" if ($binary eq "64");
+}
 
 # Do again
+
+$data = `$compiler_name $flags -E ctest.c`;
+
+if ($?) {
+    printf STDERR "C Compiler ($compiler_name) is something wrong.\n";
+    die 1;
+}
+
+$have_msa = 0;
+if (($architecture eq "mips") || ($architecture eq "mips64")) {
+    eval "use File::Temp qw(tempfile)";
+    if ($@){ 
+	warn "could not load PERL module File::Temp, so could not check MSA capatibility";
+    } else {
+	$tmpf = new File::Temp( SUFFIX => '.c' , UNLINK => 1 );
+	$code = '"addvi.b $w0, $w1, 1"';
+	$msa_flags = "-mmsa -mfp64 -mload-store-pairs";
+	print $tmpf "#include <msa.h>\n\n";
+	print $tmpf "void main(void){ __asm__ volatile($code); }\n";
+
+	$args = "$msa_flags -o $tmpf.o $tmpf";
+	my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
+	system(@cmd) == 0;
+	if ($? != 0) {
+	    $have_msa = 0;
+	} else {
+	    $have_msa = 1;
+	}
+	unlink("$tmpf.o");
+    }
+}
+
+$architecture = x86          if ($data =~ /ARCH_X86/);
+$architecture = x86_64       if ($data =~ /ARCH_X86_64/);
+$architecture = power        if ($data =~ /ARCH_POWER/);
+$architecture = mips         if ($data =~ /ARCH_MIPS/);
+$architecture = mips64       if ($data =~ /ARCH_MIPS64/);
+$architecture = alpha        if ($data =~ /ARCH_ALPHA/);
+$architecture = sparc        if ($data =~ /ARCH_SPARC/);
+$architecture = ia64         if ($data =~ /ARCH_IA64/);
+$architecture = arm          if ($data =~ /ARCH_ARM/);
+$architecture = arm64        if ($data =~ /ARCH_ARM64/);
+$architecture = zarch        if ($data =~ /ARCH_ZARCH/);
+$architecture = loongarch64  if ($data =~ /ARCH_LOONGARCH64/);
+
+$binformat    = bin32;
+$binformat    = bin64  if ($data =~ /BINARY_64/);
+
+$no_avx512= 0;
+if (($architecture eq "x86") || ($architecture eq "x86_64")) {
+    eval "use File::Temp qw(tempfile)";
+    if ($@){ 
+	warn "could not load PERL module File::Temp, so could not check compiler compatibility with AVX512";
+	$no_avx512 = 0;
+    } else {
+#	$tmpf = new File::Temp( UNLINK => 1 );
+	($fh,$tmpf) = tempfile( SUFFIX => '.c' , UNLINK => 1 );
+	$code = '"vbroadcastss -4 * 4(%rsi), %zmm2"';
+	print $tmpf "#include <immintrin.h>\n\nint main(void){ __asm__ volatile($code); }\n";
+	$args = " -march=skylake-avx512 -c -o $tmpf.o $tmpf";
+	if ($compiler eq "PGI") {
+	    $args = " -tp skylake -c -o $tmpf.o $tmpf";
+	}
+	my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
+	system(@cmd) == 0;
+	if ($? != 0) {
+	    $no_avx512 = 1;
+	} else {
+	    $no_avx512 = 0;
+	}
+	unlink("$tmpf.o");
+    }
+}
+
+$c11_atomics = 0;
+if ($data =~ /HAVE_C11/) {
+    eval "use File::Temp qw(tempfile)";
+    if ($@){ 
+       warn "could not load PERL module File::Temp, so could not check compiler compatibility with C11";
+       $c11_atomics = 0;
+    } else {
+       ($fh,$tmpf) = tempfile( SUFFIX => '.c' , UNLINK => 1 );
+       print $tmpf "#include <stdatomic.h>\nint main(void){}\n";
+       $args = " -c -o $tmpf.o $tmpf";
+       my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
+       system(@cmd) == 0;
+       if ($? != 0) {
+           $c11_atomics = 0;
+       } else {
+           $c11_atomics = 1;
+       }
+       unlink("$tmpf.o");
+    }
+}
+
+if ($compiler eq "GCC" &&( ($architecture eq "x86") || ($architecture eq "x86_64"))) {
+	$no_avx2 = 0;
+	$oldgcc = 0;
+	$data = `$compiler_name -dumpversion`;
+	if ($data <= 4.6) {
+		$no_avx2 = 1;
+		$oldgcc = 1;
+	}
+}
+
+$data = `$compiler_name $flags -S ctest1.c && grep globl ctest1.s | head -n 1 && rm -f ctest1.s`;
+
+$data =~ /globl\s([_\.]*)(.*)/;
+
+$need_fu      = $1;
+
+$cross = 0;
+
+if ($architecture ne $hostarch) {
+    $cross = 1;
+    $cross = 0 if (($hostarch eq "x86_64") && ($architecture eq "x86"));
+    $cross = 0 if (($hostarch eq "mips64") && ($architecture eq "mips"));
+}
+
+$cross = 1 if ($os ne $hostos);
+
+$openmp = "" if $ENV{USE_OPENMP} != 1;
+
+$linker_L = "";
+$linker_l = "";
+$linker_a = "";
+
 {
-    data="$($compiler_name $flags -E ctest.c)"
-} || {
-    printf '%s\n' "C Compiler ($compiler_name) is something wrong." >&2
-    exit 1
+    $link = `$compiler_name $flags -c ctest2.c -o ctest2.o 2>&1 && $compiler_name $flags $openmp -v ctest2.o -o ctest2 2>&1 && rm -f ctest2.o ctest2 ctest2.exe`;
+
+    $link =~ s/\-Y\sP\,/\-Y/g;
+
+    @flags = split(/[\s\,\n]/, $link);
+    # remove leading and trailing quotes from each flag.
+    @flags = map {s/^['"]|['"]$//g; $_} @flags;
+
+    foreach $flags (@flags) {
+	if (
+	    ($flags =~ /^\-L/)
+	    && ($flags !~ /^-LIST:/)
+	    && ($flags !~ /^-LANG:/)
+	    ) {
+	    $linker_L .= $flags . " "
+	    }
+
+	if ($flags =~ /^\-Y/) {
+	    $linker_L .= "-Wl,". $flags . " "
+	    }
+
+	if ($flags =~ /^\--exclude-libs/) {
+	    $linker_L .= "-Wl,". $flags . " ";
+	    $flags="";
+	   }
+
+	if (
+	    ($flags =~ /^\-l/)
+	    && ($flags !~ /gfortranbegin/)
+	    && ($flags !~ /frtbegin/)
+	    && ($flags !~ /pathfstart/)
+	    && ($flags !~ /numa/)
+	    && ($flags !~ /crt[0-9]/)
+	    && ($flags !~ /gcc/)
+	    && ($flags !~ /user32/)
+	    && ($flags !~ /kernel32/)
+	    && ($flags !~ /advapi32/)
+	    && ($flags !~ /shell32/)
+	    && ($flags !~ /omp/)
+	    && ($flags !~ /[0-9]+/)
+	    ) {
+	    $linker_l .= $flags . " "
+	}
+
+	$linker_a .= $flags . " " if $flags =~ /\.a$/;
+    }
+
 }
 
-no_msa=0
-if [ "$architecture" = "mips" ] || [ "$architecture" = "mips64" ]; then
-    tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
-    tmpf="$tmpd/a.c"
-    code='"addvi.b $w0, $w1, 1"'
-    msa_flags='-mmsa -mfp64 -mload-store-pairs'
-    printf "#include <msa.h>\n\n" >> "$tmpf"
-    printf "void main(void){ __asm__ volatile(%s); }\n" "$code" >> "$tmpf"
-
-    args="$msa_flags -o $tmpf.o $tmpf"
-    {
-    	$compiler_name $flags $args >/dev/null 2>&1
-    } || {
-    	no_msa=1
-    }
-
-    rm -rf "$tmpd"
-fi
-
-no_lsx=0
-no_lasx=0
-if [ "$architecture" = "loongarch64" ]; then
-    lasx_flags='-march=loongarch64'
-    lsx_flags='-march=loongarch64'
-
-    tmpd="$(mktemp -d)"
-    tmparch="$tmpd/arch.c"
-    printf "void main(void){ }\n" >> "$tmparch"
-    args="-march=loongarch64 -o $tmparch.o $tmparch"
-    {
-        $compiler_name $flags $args >/dev/null 2>&1
-    } || {
-        lasx_flags=''
-        lsx_flags=''
-    }
-
-    tmplsx="$tmpd/lsx.c"
-    codelsx='"vadd.b $vr0, $vr0, $vr0"'
-    printf "void main(void){ __asm__ volatile(%s);}\n" "$codelsx" >> "$tmplsx"
-    args="$lsx_flags -o $tmplsx.o $tmplsx"
-    {
-        $compiler_name $flags $args >/dev/null 2>&1
-    } || {
-        no_lsx=1
-    }
-
-    tmplasx="$tmpd/lasx.c"
-    codelasx='"xvadd.b $xr0, $xr0, $xr0"'
-    printf "void main(void){ __asm__ volatile(%s);}\n" "$codelasx" >> "$tmplasx"
-    args="$lasx_flags -o $tmplasx.o $tmplasx"
-    {
-        $compiler_name $flags $args >/dev/null 2>&1
-    } || {
-        no_lasx=1
-    }
-
-    rm -rf "$tmpd"
-fi
-
-case "$data" in
-    *ARCH_X86_64*) architecture=x86_64 ;;
-    *ARCH_X86*) architecture=x86 ;;
-    *ARCH_E2K*) architecture=e2k ;;
-    *ARCH_POWER*) architecture=power ;;
-    *ARCH_MIPS64*) architecture=mips64 ;;
-    *ARCH_MIPS*) architecture=mips ;;
-    *ARCH_ALPHA*) architecture=alpha ;;
-    *ARCH_SPARC*) architecture=sparc ;;
-    *ARCH_IA64*) architecture=ia64 ;;
-    *ARCH_ARM64*) architecture=arm64 ;;
-    *ARCH_ARM*) architecture=arm ;;
-    *ARCH_ZARCH*) architecture=zarch ;;
-    *ARCH_LOONGARCH64*) architecture=loongarch64 ;;
-    *ARCH_CSKY*) architecture=csky ;;
-    *ARCH_WASM*) architecture=wasm ;;
-esac
-
-binformat='bin32'
-case "$data" in
-    *BINARY_64*) binformat='bin64' ;;
-esac
-
-no_avx512=0
-no_avx512bf=0
-if [ "$architecture" = "x86" ] || [ "$architecture" = "x86_64" ]; then
-    tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
-    tmpf="$tmpd/a.c"
-    code='"vbroadcastss -4 * 4(%rsi), %zmm2"'
-    printf "#include <immintrin.h>\n\nint main(void){ __asm__ volatile(%s); }\n" "$code" >> "$tmpf"
-    if [ "$compiler" = "PGI" ]; then
-        args=" -tp skylake -c -o $tmpf.o $tmpf"
-    else
-        args=" -march=skylake-avx512 -c -o $tmpf.o $tmpf"
-    fi
-    no_avx512=0
-    {
-    	$compiler_name $flags $args >/dev/null 2>&1
-    } || {
-    	no_avx512=1
-    }
-
-    rm -rf "$tmpd"
-    if [ "$no_avx512" -eq 0 ]; then
-    tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
-    tmpf="$tmpd/a.c"
-    code='"__m512 a= _mm512_dpbf16_ps(a, (__m512bh) _mm512_loadu_si512(%1]), (__m512bh) _mm512_loadu_si512(%2]));"'
-    printf "#include <immintrin.h>\n\nint main(void){ %s; }\n" "$code" >> "$tmpf"
-    if [ "$compiler" = "PGI" ]; then
-        args=" -tp cooperlake -c -o $tmpf.o $tmpf"
-    else
-        args=" -march=cooperlake -c -o $tmpf.o $tmpf"
-    fi
-    no_avx512bf=0
-    {
-        $compiler_name $flags $args >/dev/null 2>&1
-    } || {
-        no_avx512bf=1
-    }
-
-    rm -rf "$tmpd"
-  fi
-fi
-
-no_rv64gv=0
-if [ "$architecture" = "riscv64" ]; then
-    tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
-    tmpf="$tmpd/a.c"
-    code='"vsetvli    zero, zero, e8, m1\n"'
-    printf "int main(void){ __asm__ volatile(%s); }\n" "$code" >> "$tmpf"
-    args=" -march=rv64gv -c -o $tmpf.o $tmpf"
-    no_rv64gv=0
-    {
-        $compiler_name $flags $args >/dev/null 2>&1
-    } || {
-        no_rv64gv=1
-    }
-    rm -rf "$tmpd"
-fi
-
-no_sve=0
-if [ "$architecture" = "arm64" ]; then
-    tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
-    tmpf="$tmpd/a.c"
-    printf "#include <arm_sve.h>\n\n int main(void){}\n">> "$tmpf"
-    args=" -march=armv8-a+sve -c -o $tmpf.o $tmpf"
-    no_sve=0
-    {
-        $compiler_name $flags $args >/dev/null 2>&1
-    } || {
-        args=" -Msve_intrinsics -c -o $tmpf.o $tmpf"
-        $compiler_name $flags $args >/dev/null 2>&1
-    } || {
-        no_sve=1
-    }
-    rm -rf "$tmpd"
-fi
-
-no_sme=0
-is_appleclang=0
-if [ "$architecture" = "arm64" ]; then
-    if [ "$compiler" = "CLANG" ]; then
-        vdata=`$compiler_name --version`
-	case "$vdata" in Apple*)
-	is_appleclang=1
-	esac
-    fi
-    tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
-    tmpf="$tmpd/a.S"
-    printf ".text \n.global sme_test\n\nsme_test:\nsmstart\nsmstop\nret\n">> "$tmpf"
-    args=" -march=armv9-a+sve2+sme -c -o $tmpf.o $tmpf"
-    no_sme=0
-    {
-        $compiler_name $flags $args >/dev/null 2>&1
-    } || {
-        args=" -march=armv9-a+sme -c -o $tmpf.o $tmpf"
-        $compiler_name $flags $args >/dev/null 2>&1
-    } || {
-        no_sme=1
-    }
-    rm -rf "$tmpd"
-fi
-
-c11_atomics=0
-case "$data" in
-    *HAVE_C11*)
-        tmpd=$(mktemp -d 2>/dev/null || mktemp -d -t 'OBC')
-        tmpf="$tmpd/a.c"
-        printf "#include <stdatomic.h>\nint main(void){}\n" >> "$tmpf"
-        args=" -c -o $tmpf.o $tmpf"
-        c11_atomics=1
-        {
-            $compiler_name $flags $args >/dev/null 2>&1
-        } || {
-            c11_atomics=0
-        }
-
-        rm -rf "$tmpd"
-        ;;
-esac
-
-oldgcc=0
-no_avx2=0
-if [ "$compiler" = "GCC" ]; then
-    case "$architecture" in x86|x86_64)
-        no_avx2=0
-        oldgcc=0
-        data=`$compiler_name -dumpversion`
-        case "$data" in *-*)
-            data="${data%-*}"
-        esac
-        case "$data" in *.*.*)
-            data="${data%.*}"
-        esac
-        if awk -v n1=$data -v n2=4.6 'BEGIN { exit !(n1 <= n2) }'; then
-            no_avx2=1
-            oldgcc=1
-        fi
-    esac
-fi
-
-data=`$compiler_name $flags -S ctest1.c && grep globl ctest1.s | head -n 1 && rm -f ctest1.s`
-
-need_fu=''
-if echo "$data" | grep -q 'globl[[:space:]][_\.]'; then
-    need_fu="${data##*globl[[:space:]]}"
-    need_fu="${need_fu%%[!_\.]*}"
-fi
-
-cross=0
-
-if [ "$architecture" != "$hostarch" ]; then
-    cross=1
-    [ "$hostarch" = "x86_64" ] && [ "$architecture" = "x86" ] && cross=0
-    [ "$hostarch" = "mips64" ] && [ "$architecture" = "mips" ] && cross=0
-fi
-
-[ "$os" != "$hostos" ] && cross=1
-[ "$os" = "Android" ] && [ "$hostos" = "Linux" ] && [ -n "$TERMUX_APP_PID" ] \
-    && cross=0
-
-[ "$darwin_os" = iOS ] && cross=1
-
-[ "$USE_OPENMP" != 1 ] && openmp=''
-
-linker_L=""
-linker_l=""
-linker_a=""
-
-link=`$compiler_name $flags -c ctest2.c -o ctest2.o 2>&1 && $compiler_name $flags $openmp -v ctest2.o -o ctest2 2>&1 && rm -f ctest2.o ctest2 ctest2.exe`
-
-link=`echo "$link" | sed 's/\-Y[[:space:]]P\,/\-Y/g'`
-
-
-flags=`echo $link | tr "'[[:space:]],\n" " "`
-
-# Strip trailing quotes
-old_flags="$flags"
-flags=''
-
-
-for flag in $old_flags; do
-    f=`echo "$flag" | tr '"' ' '`
-    flags="$flags $f"
-done
-
-for flag in $flags; do
-    case "$flag" in -L*)
-        case "$flag" in
-            -LIST:*|-LANG:*) ;;
-            *) linker_L="$linker_L $flag" ;;
-        esac
-    esac
-
-    case "$flag" in -Y*)
-        linker_L="$linker_L -Wl,$flag" ;;
-    esac
-
-    case "$flag" in --exclude-libs*)
-        linker_L="$linker_L -Wl,$flag"
-        flags=""
-        ;;
-    esac
-
-    case "$flag" in -l*)
-        case "$flag" in
-            *gfortranbegin*|*frtbegin*|*pathfstart*|*numa*|*crt[0-9]*|\
-                *gcc*|*user32*|*kernel32*|*advapi32*|*shell32*|*omp*|\
-                *[0-9]*) ;;
-            *) linker_l="$linker_l $flag" ;;
-        esac
-    esac
-
-    case "$flag" in *.a) linker_a="$linker_a $flag" ;; esac
-done
-
- [ "$makefile" = "-" ] && {
-    [ "$no_rv64gv" -eq 1 ] && printf "NO_RV64GV=1\n"
-    [ "$no_avx512" -eq 1 ] && printf "NO_AVX512=1\n"
-    [ "$no_avx512bf" -eq 1 ] && printf "NO_AVX512BF16=1\n"
-    [ "$no_avx2" -eq 1 ] && printf "NO_AVX2=1\n"
-    [ "$oldgcc" -eq 1 ] && printf "OLDGCC=1\n"
-    [ "$is_appleclang" -eq 1 ] && printf "APPLECLANG=1\n"
-    exit 0
-}
-
-:> "$makefile" || exit 1
-:> "$config" || exit 1
+open(MAKEFILE, "> $makefile") || die "Can't create $makefile";
+open(CONFFILE, "> $config"  ) || die "Can't create $config";
 
 # print $data, "\n";
 
-{
-    printf "OSNAME=%s\n" "$os"
-    [ -n "$darwin_os" ] && printf "OSNAME_DISPLAY=%s\n" "$darwin_os"
-    printf "ARCH=%s\n" "$architecture"
-    printf "C_COMPILER=%s\n" "$compiler"
-    [ $binformat != 'bin32' ] && printf "BINARY32=\n"
-    [ $binformat != 'bin64' ] && printf "BINARY64=\n"
-    [ "$binformat" = "bin32" ] && printf "BINARY32=1\n"
-    [ "$binformat" = "bin64" ] && printf "BINARY64=1\n"
-    [ -n "$need_fu" ] && printf 'FU=%s\n' "$need_fu"
-    [ "$cross" -ne 0 ] && [ -n "$cross_suffix" ] && \
-        printf "CROSS_SUFFIX=%s\n" "$cross_suffix"
-    [ "$cross" -ne 0 ] && printf "CROSS=1\n"
-    printf "CEXTRALIB=%s %s %s\n" "$linker_L" "$linker_l" "$linker_a"
-    [ "$no_msa" -eq 1 ] &&  printf "NO_MSA=1\n"
-    [ "$no_sve" -eq 1 ] && printf "NO_SVE=1\n"
-    [ "$no_sme" -eq 1 ] && printf "NO_SME=1\n"
-    [ "$no_rv64gv" -eq 1 ] && printf "NO_RV64GV=1\n"
-    [ "$no_avx512" -eq 1 ] && printf "NO_AVX512=1\n"
-    [ "$no_avx512bf" -eq 1 ] && printf "NO_AVX512BF16=1\n"
-    [ "$no_avx2" -eq 1 ] && printf "NO_AVX2=1\n"
-    [ "$oldgcc" -eq 1 ] && printf "OLDGCC=1\n"
-    [ "$is_appleclang" -eq 1 ] && printf "APPLECLANG=1\n"
-    [ "$no_lsx" -eq 1 ] && printf "NO_LSX=1\n"
-    [ "$no_lasx" -eq 1 ] && printf "NO_LASX=1\n"
-} >> "$makefile"
+print MAKEFILE "OSNAME=$os\n";
+print MAKEFILE "ARCH=$architecture\n";
+print MAKEFILE "C_COMPILER=$compiler\n";
+print MAKEFILE "BINARY32=\n" if $binformat ne bin32;
+print MAKEFILE "BINARY64=\n" if $binformat ne bin64;
+print MAKEFILE "BINARY32=1\n" if $binformat eq bin32;
+print MAKEFILE "BINARY64=1\n" if $binformat eq bin64;
+print MAKEFILE "FU=$need_fu\n" if $need_fu ne "";
+print MAKEFILE "CROSS_SUFFIX=$cross_suffix\n" if $cross != 0 && $cross_suffix ne "";
+print MAKEFILE "CROSS=1\n" if $cross != 0;
+print MAKEFILE "CEXTRALIB=$linker_L $linker_l $linker_a\n";
+print MAKEFILE "HAVE_MSA=1\n" if $have_msa eq 1;
+print MAKEFILE "MSA_FLAGS=$msa_flags\n" if $have_msa eq 1;
+print MAKEFILE "NO_AVX512=1\n" if $no_avx512 eq 1;
+print MAKEFILE "NO_AVX2=1\n" if $no_avx2 eq 1;
+print MAKEFILE "OLDGCC=1\n" if $oldgcc eq 1;
 
-os=`echo "$os" | tr '[[:lower:]]' '[[:upper:]]'/ `
-architecture=`echo "$architecture" | tr '[[:lower:]]' '[[:upper:]]' `
-compiler=`echo "$compiler" | tr '[[:lower:]]' '[[:upper:]]' `
+$os           =~ tr/[a-z]/[A-Z]/;
+$architecture =~ tr/[a-z]/[A-Z]/;
+$compiler     =~ tr/[a-z]/[A-Z]/;
 
-{
-    printf "#define OS_%s\t1\n" "$os"
-    printf "#define ARCH_%s\t1\n" "$architecture"
-    printf "#define C_%s\t1\n" "$compiler"
-    [ "$binformat" = "bin32" ] && printf "#define __32BIT__\t1\n"
-    [ "$binformat" = "bin64" ] && printf "#define __64BIT__\t1\n"
-    [ -n "$need_fu" ] && printf "#define FUNDERSCORE\t%s\n" "$need_fu"
-    [ "$no_msa" -eq 1 ] && printf "#define NO_MSA\t1\n"
-    [ "$c11_atomics" -eq 1 ] && printf "#define HAVE_C11\t1\n"
-    [ "$no_lsx" -eq 1 ] && printf "#define NO_LSX\t1\n"
-    [ "$no_lasx" -eq 1 ] && printf "#define NO_LASX\t1\n"
-} >> "$config"
+print CONFFILE "#define OS_$os\t1\n";
+print CONFFILE "#define ARCH_$architecture\t1\n";
+print CONFFILE "#define C_$compiler\t1\n";
+print CONFFILE "#define __32BIT__\t1\n"  if $binformat eq bin32;
+print CONFFILE "#define __64BIT__\t1\n"  if $binformat eq bin64;
+print CONFFILE "#define FUNDERSCORE\t$need_fu\n" if $need_fu ne "";
+print CONFFILE "#define HAVE_MSA\t1\n"  if $have_msa eq 1;
+print CONFFILE "#define HAVE_C11\t1\n" if $c11_atomics eq 1;
 
 
-if [ "$os" = "LINUX" ]; then
+if ($os eq "LINUX") {
 
 #    @pthread = split(/\s+/, `nm /lib/libpthread.so* | grep _pthread_create`);
 
 #    if ($pthread[2] ne "") {
 #	print CONFFILE "#define PTHREAD_CREATE_FUNC	$pthread[2]\n";
 #    } else {
-	printf "#define PTHREAD_CREATE_FUNC	pthread_create\n" >> "$config"
+	print CONFFILE "#define PTHREAD_CREATE_FUNC	pthread_create\n";
 #    }
-else
-    printf "#define PTHREAD_CREATE_FUNC	pthread_create\n" >> "$config"
-fi
+} else {
+    print CONFFILE "#define PTHREAD_CREATE_FUNC	pthread_create\n";
+}
+
+close(MAKEFILE);
+close(CONFFILE);

c_check.pl

@@ -1,515 +0,0 @@
-#!/usr/bin/env perl
-
-#use File::Basename;
-# use File::Temp qw(tempfile);
-
-# Checking cross compile
-$hostos   = `uname -s | sed -e s/\-.*//`;    chop($hostos);
-$hostarch = `uname -m | sed -e s/i.86/x86/`;
-$hostarch = `uname -p` if ($hostos eq "AIX" || $hostos eq "SunOS");
-chop($hostarch);
-$hostarch = "x86_64" if ($hostarch eq "amd64");
-$hostarch = "arm" if ($hostarch ne "arm64" && $hostarch =~ /^arm.*/);
-$hostarch = "arm64" if ($hostarch eq "aarch64");
-$hostarch = "power" if ($hostarch =~ /^(powerpc|ppc).*/);
-$hostarch = "zarch" if ($hostarch eq "s390x");
-
-#$tmpf = new File::Temp( UNLINK => 1 );
-$binary = $ENV{"BINARY"};
-
-$makefile = shift(@ARGV);
-$config   = shift(@ARGV);
-
-$compiler_name = shift(@ARGV);
-$flags = join(" ", @ARGV);
-
-# First, we need to know the target OS and compiler name
-
-$data = `$compiler_name $flags -E ctest.c`;
-
-if ($?) {
-    printf STDERR "C Compiler ($compiler_name) is something wrong.\n";
-    die 1;
-}
-
-$cross_suffix = "";
-
-eval "use File::Basename";
-if ($@){ 
-    warn "could not load PERL module File::Basename, emulating its functionality";
-    my $dirnam = substr($compiler_name, 0, rindex($compiler_name, "/")-1 );
-    if ($dirnam ne ".") {
-	$cross_suffix .= $dirnam . "/";
-    }
-    my $basnam = substr($compiler_name, rindex($compiler_name,"/")+1, length($compiler_name)-rindex($compiler_name,"/")-1);
-	if ($basnam =~ /([^\s]*-)(.*)/) {
-	$cross_suffix .= $1;
-    }
-} else {
-    if (dirname($compiler_name) ne ".") {
-	$cross_suffix .= dirname($compiler_name) . "/";
-    }
-
-    if (basename($compiler_name) =~ /([^\s]*-)(.*)/) {
-	$cross_suffix .= $1;
-    }
-}
-
-$compiler = "";
-$darwin_os = "";
-$compiler = LSB       if ($data =~ /COMPILER_LSB/);
-$compiler = CLANG     if ($data =~ /COMPILER_CLANG/);
-$compiler = PGI       if ($data =~ /COMPILER_PGI/);
-$compiler = PATHSCALE if ($data =~ /COMPILER_PATHSCALE/);
-$compiler = INTEL     if ($data =~ /COMPILER_INTEL/);
-$compiler = OPEN64    if ($data =~ /COMPILER_OPEN64/);
-$compiler = SUN       if ($data =~ /COMPILER_SUN/);
-$compiler = IBM       if ($data =~ /COMPILER_IBM/);
-$compiler = DEC       if ($data =~ /COMPILER_DEC/);
-$compiler = FUJITSU   if ($data =~ /COMPILER_FUJITSU/);
-$compiler = GCC       if ($compiler eq "");
-
-$os = Linux           if ($data =~ /OS_LINUX/);
-$os = FreeBSD         if ($data =~ /OS_FREEBSD/);
-$os = NetBSD          if ($data =~ /OS_NETBSD/);
-$os = OpenBSD         if ($data =~ /OS_OPENBSD/);
-$os = DragonFly       if ($data =~ /OS_DRAGONFLY/);
-if ($data =~ /OS_DARWIN/) {
-    $os = Darwin;
-    $darwin_os = "macOS";
-}
-if ($data =~ /OS_IOS/) {
-    $darwin_os = "iOS";
-}
-$os = SunOS           if ($data =~ /OS_SUNOS/);
-$os = AIX             if ($data =~ /OS_AIX/);
-$os = osf             if ($data =~ /OS_OSF/);
-$os = WINNT           if ($data =~ /OS_WINNT/);
-$os = CYGWIN_NT       if ($data =~ /OS_CYGWIN_NT/);
-$os = Interix         if ($data =~ /OS_INTERIX/);
-$os = Android         if ($data =~ /OS_ANDROID/);
-$os = Haiku           if ($data =~ /OS_HAIKU/);
-
-$architecture = x86          if ($data =~ /ARCH_X86/);
-$architecture = x86_64       if ($data =~ /ARCH_X86_64/);
-$architecture = e2k          if ($data =~ /ARCH_E2K/);
-$architecture = power        if ($data =~ /ARCH_POWER/);
-$architecture = mips         if ($data =~ /ARCH_MIPS/);
-$architecture = mips64       if ($data =~ /ARCH_MIPS64/);
-$architecture = alpha        if ($data =~ /ARCH_ALPHA/);
-$architecture = sparc        if ($data =~ /ARCH_SPARC/);
-$architecture = ia64         if ($data =~ /ARCH_IA64/);
-$architecture = arm          if ($data =~ /ARCH_ARM/);
-$architecture = arm64        if ($data =~ /ARCH_ARM64/);
-$architecture = zarch        if ($data =~ /ARCH_ZARCH/);
-$architecture = riscv64      if ($data =~ /ARCH_RISCV64/);
-$architecture = loongarch64  if ($data =~ /ARCH_LOONGARCH64/);
-$architecture = csky         if ($data =~ /ARCH_CSKY/);
-
-$defined = 0;
-
-if ($os eq "AIX") {
-    $compiler_name .= " -maix32" if ($binary eq "32");
-    $compiler_name .= " -maix64" if ($binary eq "64");
-    $defined = 1;
-}
-
-if ($architecture eq "mips") {
-    $compiler_name .= " -mabi=32";
-    $defined = 1;
-}
-
-if ($architecture eq "mips64") {
-    $compiler_name .= " -mabi=n32" if ($binary eq "32");
-    $compiler_name .= " -mabi=64" if ($binary eq "64");
-    $defined = 1;
-}
-
-if (($architecture eq "arm") || ($architecture eq "arm64")) {
-    $defined = 1;
-}
-
-if ($architecture eq "zarch") {
-    $defined = 1;
-    $binary = 64;
-}
-
-if ($architecture eq "e2k") {
-    $defined = 1;
-    $binary = 64;
-}
-
-if ($architecture eq "alpha") {
-    $defined = 1;
-    $binary = 64;
-}
-
-if ($architecture eq "ia64") {
-    $defined = 1;
-    $binary = 64;
-}
-
-if (($architecture eq "x86") && ($os ne Darwin) && ($os ne SunOS)) {
-    $defined = 1;
-    $binary =32;
-}
-
-if ($architecture eq "riscv64") {
-    $defined = 1;
-    $binary = 64;
-}
-
-if ($architecture eq "loongarch64") {
-    $defined = 1;
-    $binary = 64;
-}
-
-if ($architecture eq "csky") {
-    $defined = 1;
-    $binary = 32;
-}
-
-if ($compiler eq "PGI") {
-    $compiler_name .= " -tp p7"    if ($binary eq "32");
-    $compiler_name .= " -tp p7-64" if ($binary eq "64");
-    $openmp = "-mp";
-    $defined = 1;
-}
-
-if ($compiler eq "IBM") {
-    $compiler_name .= " -q32"  if ($binary eq "32");
-    $compiler_name .= " -q64"  if ($binary eq "64");
-    $openmp = "-qsmp=omp";
-    $defined = 1;
-}
-
-if ($compiler eq "INTEL") {
-    $openmp = "-openmp";
-}
-
-if ($compiler eq "PATHSCALE") {
-    $openmp = "-mp";
-}
-
-if ($compiler eq "OPEN64") {
-    $openmp = "-mp";
-}
-
-if ($compiler eq "CLANG") {
-    $openmp = "-fopenmp";
-}
-
-if ($compiler eq "GCC" || $compiler eq "LSB") {
-    $openmp = "-fopenmp";
-}
-
-if ($compiler eq "FUJITSU") {
-    $openmp = "-Kopenmp";
-}
-
-if ($defined == 0) {
-    $compiler_name .= " -m32" if ($binary eq "32");
-    $compiler_name .= " -m64" if ($binary eq "64");
-}
-
-# Do again
-
-$data = `$compiler_name $flags -E ctest.c`;
-
-if ($?) {
-    printf STDERR "C Compiler ($compiler_name) is something wrong.\n";
-    die 1;
-}
-
-$have_msa = 0;
-if (($architecture eq "mips") || ($architecture eq "mips64")) {
-    eval "use File::Temp qw(tempfile)";
-    if ($@){ 
-	warn "could not load PERL module File::Temp, so could not check MSA capatibility";
-    } else {
-	$tmpf = new File::Temp( SUFFIX => '.c' , UNLINK => 1 );
-	$code = '"addvi.b $w0, $w1, 1"';
-	$msa_flags = "-mmsa -mfp64 -mload-store-pairs";
-	print $tmpf "#include <msa.h>\n\n";
-	print $tmpf "void main(void){ __asm__ volatile($code); }\n";
-
-	$args = "$msa_flags -o $tmpf.o $tmpf";
-	my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
-	system(@cmd) == 0;
-	if ($? != 0) {
-	    $have_msa = 0;
-	} else {
-	    $have_msa = 1;
-	}
-	unlink("$tmpf.o");
-    }
-}
-
-$no_lsx = 0;
-$no_lasx = 0;
-if (($architecture eq "loongarch64")) {
-    eval "use File::Temp qw(tempfile)";
-    if ($@){
-	warn "could not load PERL module File::Temp, so could not check LSX and LASX capatibility";
-    } else {
-	$tmplsx = new File::Temp( SUFFIX => '.c' , UNLINK => 1 );
-	$codelsx = '"vadd.b $vr0, $vr0, $vr0"';
-	$lsx_flags = "-march=loongarch64";
-	print $tmplsx "void main(void){ __asm__ volatile($codelsx); }\n";
-
-	$args = "$lsx_flags -o $tmplsx.o $tmplsx";
-	my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
-	system(@cmd) == 0;
-	if ($? != 0) {
-	    $no_lsx = 1;
-	} else {
-	    $no_lsx = 0;
-	}
-	unlink("$tmplsx.o");
-
-	$tmplasx = new File::Temp( SUFFIX => '.c' , UNLINK => 1 );
-	$codelasx = '"xvadd.b $xr0, $xr0, $xr0"';
-	$lasx_flags = "-march=loongarch64";
-	print $tmplasx "void main(void){ __asm__ volatile($codelasx); }\n";
-
-	$args = "$lasx_flags -o $tmplasx.o $tmplasx";
-	my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
-	system(@cmd) == 0;
-	if ($? != 0) {
-	    $no_lasx = 1;
-	} else {
-	    $no_lasx = 0;
-	}
-	unlink("$tmplasx.o");
-    }
-}
-
-$architecture = x86          if ($data =~ /ARCH_X86/);
-$architecture = x86_64       if ($data =~ /ARCH_X86_64/);
-$architecture = e2k          if ($data =~ /ARCH_E2K/);
-$architecture = power        if ($data =~ /ARCH_POWER/);
-$architecture = mips         if ($data =~ /ARCH_MIPS/);
-$architecture = mips64       if ($data =~ /ARCH_MIPS64/);
-$architecture = alpha        if ($data =~ /ARCH_ALPHA/);
-$architecture = sparc        if ($data =~ /ARCH_SPARC/);
-$architecture = ia64         if ($data =~ /ARCH_IA64/);
-$architecture = arm          if ($data =~ /ARCH_ARM/);
-$architecture = arm64        if ($data =~ /ARCH_ARM64/);
-$architecture = zarch        if ($data =~ /ARCH_ZARCH/);
-$architecture = loongarch64  if ($data =~ /ARCH_LOONGARCH64/);
-$architecture = csky         if ($data =~ /ARCH_CSKY/);
-
-$binformat    = bin32;
-$binformat    = bin64  if ($data =~ /BINARY_64/);
-
-$no_avx512= 0;
-if (($architecture eq "x86") || ($architecture eq "x86_64")) {
-    eval "use File::Temp qw(tempfile)";
-    if ($@){ 
-	warn "could not load PERL module File::Temp, so could not check compiler compatibility with AVX512";
-	$no_avx512 = 0;
-    } else {
-#	$tmpf = new File::Temp( UNLINK => 1 );
-	($fh,$tmpf) = tempfile( SUFFIX => '.c' , UNLINK => 1 );
-	$code = '"vbroadcastss -4 * 4(%rsi), %zmm2"';
-	print $fh "#include <immintrin.h>\n\nint main(void){ __asm__ volatile($code); }\n";
-	$args = " -march=skylake-avx512 -c -o $tmpf.o $tmpf";
-	if ($compiler eq "PGI") {
-	    $args = " -tp skylake -c -o $tmpf.o $tmpf";
-	}
-	my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
-	system(@cmd) == 0;
-	if ($? != 0) {
-	    $no_avx512 = 1;
-	} else {
-	    $no_avx512 = 0;
-	}
-	unlink("$tmpf.o");
-    }
-}
-
-$no_rv64gv= 0;
-if (($architecture eq "riscv64")) {
-    eval "use File::Temp qw(tempfile)";
-    if ($@){ 
-	warn "could not load PERL module File::Temp, so could not check compiler compatibility with the RISCV vector extension";
-	$no_rv64gv = 0;
-    } else {
-#	$tmpf = new File::Temp( UNLINK => 1 );
-	($fh,$tmpf) = tempfile( SUFFIX => '.c' , UNLINK => 1 );
-	$code = '"vsetvli    zero, zero, e8, m1\n"';
-	print $fh "int main(void){ __asm__ volatile($code); }\n";
-	$args = " -march=rv64gv -c -o $tmpf.o $tmpf";
-	my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
-	system(@cmd) == 0;
-	if ($? != 0) {
-	    $no_rv64gv = 1;
-	} else {
-	    $no_rv64gv = 0;
-	}
-	unlink("$tmpf.o");
-    }
-}
-
-$c11_atomics = 0;
-if ($data =~ /HAVE_C11/) {
-    eval "use File::Temp qw(tempfile)";
-    if ($@){ 
-       warn "could not load PERL module File::Temp, so could not check compiler compatibility with C11";
-       $c11_atomics = 0;
-    } else {
-       ($fh,$tmpf) = tempfile( SUFFIX => '.c' , UNLINK => 1 );
-       print $fh "#include <stdatomic.h>\nint main(void){}\n";
-       $args = " -c -o $tmpf.o $tmpf";
-       my @cmd = ("$compiler_name $flags $args >/dev/null 2>/dev/null");
-       system(@cmd) == 0;
-       if ($? != 0) {
-           $c11_atomics = 0;
-       } else {
-           $c11_atomics = 1;
-       }
-       unlink("$tmpf.o");
-    }
-}
-
-if ($compiler eq "GCC" &&( ($architecture eq "x86") || ($architecture eq "x86_64"))) {
-	$no_avx2 = 0;
-	$oldgcc = 0;
-	$data = `$compiler_name -dumpversion`;
-	if ($data <= 4.6) {
-		$no_avx2 = 1;
-		$oldgcc = 1;
-	}
-}
-
-$data = `$compiler_name $flags -S ctest1.c && grep globl ctest1.s | head -n 1 && rm -f ctest1.s`;
-
-$data =~ /globl\s([_\.]*)(.*)/;
-
-$need_fu      = $1;
-
-$cross = 0;
-
-if ($architecture ne $hostarch) {
-    $cross = 1;
-    $cross = 0 if (($hostarch eq "x86_64") && ($architecture eq "x86"));
-    $cross = 0 if (($hostarch eq "mips64") && ($architecture eq "mips"));
-}
-
-$cross = 1 if ($os ne $hostos);
-$cross = 0 if (($os eq "Android") && ($hostos eq "Linux") && ($ENV{TERMUX_APP_PID} != ""));
-$cross = 1 if $darwin_os eq "iOS";
-
-$openmp = "" if $ENV{USE_OPENMP} != 1;
-
-$linker_L = "";
-$linker_l = "";
-$linker_a = "";
-
-{
-    $link = `$compiler_name $flags -c ctest2.c -o ctest2.o 2>&1 && $compiler_name $flags $openmp -v ctest2.o -o ctest2 2>&1 && rm -f ctest2.o ctest2 ctest2.exe`;
-
-    $link =~ s/\-Y\sP\,/\-Y/g;
-
-    @flags = split(/[\s\,\n]/, $link);
-    # remove leading and trailing quotes from each flag.
-    @flags = map {s/^['"]|['"]$//g; $_} @flags;
-
-    foreach $flags (@flags) {
-	if (
-	    ($flags =~ /^\-L/)
-	    && ($flags !~ /^-LIST:/)
-	    && ($flags !~ /^-LANG:/)
-	    ) {
-	    $linker_L .= $flags . " "
-	    }
-
-	if ($flags =~ /^\-Y/) {
-	    $linker_L .= "-Wl,". $flags . " "
-	    }
-
-	if ($flags =~ /^\--exclude-libs/) {
-	    $linker_L .= "-Wl,". $flags . " ";
-	    $flags="";
-	   }
-
-	if (
-	    ($flags =~ /^\-l/)
-	    && ($flags !~ /gfortranbegin/)
-	    && ($flags !~ /frtbegin/)
-	    && ($flags !~ /pathfstart/)
-	    && ($flags !~ /numa/)
-	    && ($flags !~ /crt[0-9]/)
-	    && ($flags !~ /gcc/)
-	    && ($flags !~ /user32/)
-	    && ($flags !~ /kernel32/)
-	    && ($flags !~ /advapi32/)
-	    && ($flags !~ /shell32/)
-	    && ($flags !~ /omp/)
-	    && ($flags !~ /[0-9]+/)
-	    ) {
-	    $linker_l .= $flags . " "
-	}
-
-	$linker_a .= $flags . " " if $flags =~ /\.a$/;
-    }
-
-}
-
-open(MAKEFILE, "> $makefile") || die "Can't create $makefile";
-open(CONFFILE, "> $config"  ) || die "Can't create $config";
-
-# print $data, "\n";
-
-print MAKEFILE "OSNAME=$os\n";
-print MAKEFILE "OSNAME_DISPLAY=$darwin_os\n" if $darwin_os ne "";
-print MAKEFILE "ARCH=$architecture\n";
-print MAKEFILE "C_COMPILER=$compiler\n";
-print MAKEFILE "BINARY32=\n" if $binformat ne bin32;
-print MAKEFILE "BINARY64=\n" if $binformat ne bin64;
-print MAKEFILE "BINARY32=1\n" if $binformat eq bin32;
-print MAKEFILE "BINARY64=1\n" if $binformat eq bin64;
-print MAKEFILE "FU=$need_fu\n" if $need_fu ne "";
-print MAKEFILE "CROSS_SUFFIX=$cross_suffix\n" if $cross != 0 && $cross_suffix ne "";
-print MAKEFILE "CROSS=1\n" if $cross != 0;
-print MAKEFILE "CEXTRALIB=$linker_L $linker_l $linker_a\n";
-print MAKEFILE "HAVE_MSA=1\n" if $have_msa eq 1;
-print MAKEFILE "MSA_FLAGS=$msa_flags\n" if $have_msa eq 1;
-print MAKEFILE "NO_RV64GV=1\n" if $no_rv64gv eq 1;
-print MAKEFILE "NO_AVX512=1\n" if $no_avx512 eq 1;
-print MAKEFILE "NO_AVX2=1\n" if $no_avx2 eq 1;
-print MAKEFILE "OLDGCC=1\n" if $oldgcc eq 1;
-print MAKEFILE "NO_LSX=1\n" if $no_lsx eq 1;
-print MAKEFILE "NO_LASX=1\n" if $no_lasx eq 1;
-
-$os           =~ tr/[a-z]/[A-Z]/;
-$architecture =~ tr/[a-z]/[A-Z]/;
-$compiler     =~ tr/[a-z]/[A-Z]/;
-
-print CONFFILE "#define OS_$os\t1\n";
-print CONFFILE "#define ARCH_$architecture\t1\n";
-print CONFFILE "#define C_$compiler\t1\n";
-print CONFFILE "#define __32BIT__\t1\n"  if $binformat eq bin32;
-print CONFFILE "#define __64BIT__\t1\n"  if $binformat eq bin64;
-print CONFFILE "#define FUNDERSCORE\t$need_fu\n" if $need_fu ne "";
-print CONFFILE "#define HAVE_MSA\t1\n"  if $have_msa eq 1;
-print CONFFILE "#define HAVE_C11\t1\n" if $c11_atomics eq 1;
-print CONFFILE "#define NO_LSX\t1\n" if $no_lsx eq 1;
-print CONFFILE "#define NO_LASX\t1\n" if $no_lasx eq 1;
-
-
-if ($os eq "LINUX") {
-
-#    @pthread = split(/\s+/, `nm /lib/libpthread.so* | grep _pthread_create`);
-
-#    if ($pthread[2] ne "") {
-#	print CONFFILE "#define PTHREAD_CREATE_FUNC	$pthread[2]\n";
-#    } else {
-	print CONFFILE "#define PTHREAD_CREATE_FUNC	pthread_create\n";
-#    }
-} else {
-    print CONFFILE "#define PTHREAD_CREATE_FUNC	pthread_create\n";
-}
-
-close(MAKEFILE);
-close(CONFFILE);

cblas.h

@@ -1,31 +1,3 @@
-/***************************************************************************
- * Copyright (c) 2025, The OpenBLAS Project
- * All rights reserved.
- * Redistribution and use in source and binary forms, with or without
- * modification, are permitted provided that the following conditions are
- * met:
- * 1. Redistributions of source code must retain the above copyright
- * notice, this list of conditions and the following disclaimer.
- * 2. 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.
- * 3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
- * ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
- * *****************************************************************************/
-
 #ifndef CBLAS_H
 #define CBLAS_H
 
@@ -38,71 +10,28 @@ extern "C" {
 #endif  /* __cplusplus */
 
 /*Set the number of threads on runtime.*/
-OPENBLAS_EXPORT void openblas_set_num_threads(int num_threads);
-OPENBLAS_EXPORT void goto_set_num_threads(int num_threads);
-OPENBLAS_EXPORT int openblas_set_num_threads_local(int num_threads);
+void openblas_set_num_threads(int num_threads);
+void goto_set_num_threads(int num_threads);
 
 /*Get the number of threads on runtime.*/
-OPENBLAS_EXPORT int openblas_get_num_threads(void);
+int openblas_get_num_threads(void);
 
 /*Get the number of physical processors (cores).*/
-OPENBLAS_EXPORT int openblas_get_num_procs(void);
+int openblas_get_num_procs(void);
 
 /*Get the build configure on runtime.*/
-OPENBLAS_EXPORT char* openblas_get_config(void);
+char* openblas_get_config(void);
 
 /*Get the CPU corename on runtime.*/
-OPENBLAS_EXPORT char* openblas_get_corename(void);
-
-/*Set the threading backend to a custom callback.*/
-typedef void (*openblas_dojob_callback)(int thread_num, void *jobdata, int dojob_data);
-typedef void (*openblas_threads_callback)(int sync, openblas_dojob_callback dojob, int numjobs, size_t jobdata_elsize, void *jobdata, int dojob_data);
-OPENBLAS_EXPORT void openblas_set_threads_callback_function(openblas_threads_callback callback);
-
-/* Replace the XERBLA handler for this OpenBLAS instance and return the
- * previous handler. Passing NULL restores the default. Callbacks may run
- * concurrently and must be thread-safe. The name and info pointers are valid
- * only during the callback; name spans name_length bytes and need not be
- * NUL-terminated. Replacement is thread-safe but does not wait for in-flight
- * calls, so the previous handler must remain loaded until they complete. */
-#ifndef OPENBLAS_XERBLA_HANDLER_DEFINED
-#define OPENBLAS_XERBLA_HANDLER_DEFINED
-typedef void (*openblas_xerbla_handler)(const char *name,
-                                        const blasint *info,
-                                        size_t name_length);
-#endif
-OPENBLAS_EXPORT openblas_xerbla_handler openblas_set_xerbla(openblas_xerbla_handler handler);
-
-/* Cooperative cancellation of in-flight operations.
- *
- * Every thread owns a pointer-sized generation slot;
- * openblas_cancel_token() returns its (stable) address for the calling
- * thread.  Supported compute drivers (currently the level-3 GEMM drivers)
- * advance the slot to a fresh even generation at operation entry on the
- * issuing thread and poll it during the computation.  To cancel the
- * operation in flight on a thread, load that thread's slot value, verify
- * the operation you mean to cancel is still the current one, and call
- * openblas_cancel(token, loaded_value): the cancel bit (bit 0) is set iff
- * the slot still holds the loaded value, so stale requests cannot affect
- * later operations.  A cancelled operation leaves its output in an
- * unspecified, partially-updated state; the caller must discard the
- * result.  The library itself stays consistent and can service further
- * calls.  openblas_cancel_token() may return NULL if per-thread state
- * cannot be allocated; cancellation is then unavailable on that thread
- * (openblas_cancel(NULL, ...) is a harmless no-op).  These symbols are
- * exported without any symbol prefix/suffix decoration. */
-size_t *openblas_cancel_token(void);
-OPENBLAS_EXPORT void openblas_cancel(size_t *token, size_t loaded_token);
+char* openblas_get_corename(void);
 
 #ifdef OPENBLAS_OS_LINUX
 /* Sets thread affinity for OpenBLAS threads. `thread_idx` is in [0, openblas_get_num_threads()-1]. */
-OPENBLAS_EXPORT int openblas_setaffinity(int thread_idx, size_t cpusetsize, cpu_set_t* cpu_set);
-/* Queries thread affinity for OpenBLAS threads. `thread_idx` is in [0, openblas_get_num_threads()-1]. */
-OPENBLAS_EXPORT int openblas_getaffinity(int thread_idx, size_t cpusetsize, cpu_set_t* cpu_set);
+int openblas_setaffinity(int thread_idx, size_t cpusetsize, cpu_set_t* cpu_set);
 #endif
 
 /* Get the parallelization type which is used by OpenBLAS */
-OPENBLAS_EXPORT int openblas_get_parallel(void);
+int openblas_get_parallel(void);
 /* OpenBLAS is compiled for sequential use  */
 #define OPENBLAS_SEQUENTIAL  0
 /* OpenBLAS is compiled using normal threading model */
@@ -129,402 +58,350 @@ typedef enum CBLAS_DIAG      {CblasNonUnit=131, CblasUnit=132} CBLAS_DIAG;
 typedef enum CBLAS_SIDE      {CblasLeft=141, CblasRight=142} CBLAS_SIDE;
 typedef CBLAS_ORDER CBLAS_LAYOUT;
 	
-OPENBLAS_EXPORT float  cblas_sdsdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT double cblas_dsdot (OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT float  cblas_sdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT double cblas_ddot(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy);
+float  cblas_sdsdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float *y, OPENBLAS_CONST blasint incy);
+double cblas_dsdot (OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float *y, OPENBLAS_CONST blasint incy);
+float  cblas_sdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float  *y, OPENBLAS_CONST blasint incy);
+double cblas_ddot(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST double *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT openblas_complex_float  cblas_cdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT openblas_complex_float  cblas_cdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT openblas_complex_double cblas_zdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT openblas_complex_double cblas_zdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy);
+openblas_complex_float  cblas_cdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy);
+openblas_complex_float  cblas_cdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy);
+openblas_complex_double cblas_zdotu(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy);
+openblas_complex_double cblas_zdotc(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT void  cblas_cdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy, void  *ret);
-OPENBLAS_EXPORT void  cblas_cdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy, void  *ret);
-OPENBLAS_EXPORT void  cblas_zdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy, void *ret);
-OPENBLAS_EXPORT void  cblas_zdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy, void *ret);
+void  cblas_cdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy, void  *ret);
+void  cblas_cdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void  *y, OPENBLAS_CONST blasint incy, void  *ret);
+void  cblas_zdotu_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy, void *ret);
+void  cblas_zdotc_sub(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST void *y, OPENBLAS_CONST blasint incy, void *ret);
 
-OPENBLAS_EXPORT float  cblas_sasum (OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT double cblas_dasum (OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT float  cblas_scasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT double cblas_dzasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+float  cblas_sasum (OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+double cblas_dasum (OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+float  cblas_scasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
+double cblas_dzasum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
 
-OPENBLAS_EXPORT float  cblas_ssum (OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT double cblas_dsum (OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT float  cblas_scsum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT double cblas_dzsum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+float  cblas_ssum (OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+double cblas_dsum (OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+float  cblas_scsum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
+double cblas_dzsum(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
 
-OPENBLAS_EXPORT float  cblas_snrm2 (OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT double cblas_dnrm2 (OPENBLAS_CONST blasint N, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT float  cblas_scnrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST void  *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT double cblas_dznrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX);
+float  cblas_snrm2 (OPENBLAS_CONST blasint N, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX);
+double cblas_dnrm2 (OPENBLAS_CONST blasint N, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX);
+float  cblas_scnrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST void  *X, OPENBLAS_CONST blasint incX);
+double cblas_dznrm2(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX);
 
-OPENBLAS_EXPORT CBLAS_INDEX cblas_isamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_idamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_icamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_izamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_isamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_idamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_icamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_izamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
 
-OPENBLAS_EXPORT CBLAS_INDEX cblas_isamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_idamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_icamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_izamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_isamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_idamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_icamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_izamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
 
-OPENBLAS_EXPORT float cblas_samax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT double cblas_damax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT float cblas_scamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT double cblas_dzamax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_ismax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_idmax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_icmax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_izmax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
 
-OPENBLAS_EXPORT float cblas_samin(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT double cblas_damin(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT float cblas_scamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT double cblas_dzamin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_ismin(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_idmin(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_icmin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
+CBLAS_INDEX cblas_izmin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
 
-OPENBLAS_EXPORT CBLAS_INDEX cblas_ismax(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_idmax(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_icmax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_izmax(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+void cblas_saxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_daxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
+void cblas_caxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
+void cblas_zaxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT CBLAS_INDEX cblas_ismin(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_idmin(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_icmin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx);
-OPENBLAS_EXPORT CBLAS_INDEX cblas_izmin(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx);
+void cblas_scopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_dcopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
+void cblas_ccopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
+void cblas_zcopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT void cblas_saxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_daxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_caxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_zaxpy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
+void cblas_sswap(OPENBLAS_CONST blasint n, float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
+void cblas_dswap(OPENBLAS_CONST blasint n, double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
+void cblas_cswap(OPENBLAS_CONST blasint n, void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
+void cblas_zswap(OPENBLAS_CONST blasint n, void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT void cblas_caxpyc(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_zaxpyc(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
+void cblas_srot(OPENBLAS_CONST blasint N, float *X, OPENBLAS_CONST blasint incX, float *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float c, OPENBLAS_CONST float s);
+void cblas_drot(OPENBLAS_CONST blasint N, double *X, OPENBLAS_CONST blasint incX, double *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double c, OPENBLAS_CONST double  s);
+void cblas_csrot(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float c, OPENBLAS_CONST float s);
+void cblas_zdrot(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double c, OPENBLAS_CONST double s);
 
-OPENBLAS_EXPORT void cblas_scopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_dcopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_ccopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_zcopy(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
-
-OPENBLAS_EXPORT void cblas_sswap(OPENBLAS_CONST blasint n, float *x, OPENBLAS_CONST blasint incx, float *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_dswap(OPENBLAS_CONST blasint n, double *x, OPENBLAS_CONST blasint incx, double *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_cswap(OPENBLAS_CONST blasint n, void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_zswap(OPENBLAS_CONST blasint n, void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incy);
-
-OPENBLAS_EXPORT void cblas_srot(OPENBLAS_CONST blasint N, float *X, OPENBLAS_CONST blasint incX, float *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float c, OPENBLAS_CONST float s);
-OPENBLAS_EXPORT void cblas_drot(OPENBLAS_CONST blasint N, double *X, OPENBLAS_CONST blasint incX, double *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double c, OPENBLAS_CONST double  s);
-OPENBLAS_EXPORT void cblas_csrot(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float c, OPENBLAS_CONST float s);
-OPENBLAS_EXPORT void cblas_zdrot(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx, void *y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double c, OPENBLAS_CONST double s);
-
-OPENBLAS_EXPORT void cblas_srotg(float *a, float *b, float *c, float *s);
-OPENBLAS_EXPORT void cblas_drotg(double *a, double *b, double *c, double *s);
-OPENBLAS_EXPORT void cblas_crotg(void *a, void *b, float *c, void *s);
-OPENBLAS_EXPORT void cblas_zrotg(void *a, void *b, double *c, void *s);
+void cblas_srotg(float *a, float *b, float *c, float *s);
+void cblas_drotg(double *a, double *b, double *c, double *s);
+void cblas_crotg(void *a, void *b, float *c, void *s);
+void cblas_zrotg(void *a, void *b, double *c, void *s);
 
 
-OPENBLAS_EXPORT void cblas_srotm(OPENBLAS_CONST blasint N, float *X, OPENBLAS_CONST blasint incX, float *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float *P);
-OPENBLAS_EXPORT void cblas_drotm(OPENBLAS_CONST blasint N, double *X, OPENBLAS_CONST blasint incX, double *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double *P);
+void cblas_srotm(OPENBLAS_CONST blasint N, float *X, OPENBLAS_CONST blasint incX, float *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST float *P);
+void cblas_drotm(OPENBLAS_CONST blasint N, double *X, OPENBLAS_CONST blasint incX, double *Y, OPENBLAS_CONST blasint incY, OPENBLAS_CONST double *P);
 
-OPENBLAS_EXPORT void cblas_srotmg(float *d1, float *d2, float *b1, OPENBLAS_CONST float b2, float *P);
-OPENBLAS_EXPORT void cblas_drotmg(double *d1, double *d2, double *b1, OPENBLAS_CONST double b2, double *P);
+void cblas_srotmg(float *d1, float *d2, float *b1, OPENBLAS_CONST float b2, float *P);
+void cblas_drotmg(double *d1, double *d2, double *b1, OPENBLAS_CONST double b2, double *P);
 
-OPENBLAS_EXPORT void cblas_sscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, float *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_dscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, double *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_cscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, void *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_zscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, void *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_csscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, void *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_zdscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, void *X, OPENBLAS_CONST blasint incX);
+void cblas_sscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, double *X, OPENBLAS_CONST blasint incX);
+void cblas_cscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, void *X, OPENBLAS_CONST blasint incX);
+void cblas_zscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, void *X, OPENBLAS_CONST blasint incX);
+void cblas_csscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, void *X, OPENBLAS_CONST blasint incX);
+void cblas_zdscal(OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, void *X, OPENBLAS_CONST blasint incX);
 
-OPENBLAS_EXPORT void cblas_sgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
+void cblas_sgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
 		 OPENBLAS_CONST float alpha, OPENBLAS_CONST float  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST float  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST float beta,  float  *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_dgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
+void cblas_dgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
 		 OPENBLAS_CONST double alpha, OPENBLAS_CONST double  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST double  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST double beta,  double  *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_cgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
+void cblas_cgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST void *beta,  void  *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void cblas_zgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
+void cblas_zgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void  *a, OPENBLAS_CONST blasint lda,  OPENBLAS_CONST void  *x, OPENBLAS_CONST blasint incx,  OPENBLAS_CONST void *beta,  void  *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT void cblas_sger (OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float   alpha, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float  *Y, OPENBLAS_CONST blasint incY, float  *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_dger (OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double  alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_cgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void  *alpha, OPENBLAS_CONST void  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void  *Y, OPENBLAS_CONST blasint incY, void  *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_cgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void  *alpha, OPENBLAS_CONST void  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void  *Y, OPENBLAS_CONST blasint incY, void  *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_zgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_zgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
+void cblas_sger (OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float   alpha, OPENBLAS_CONST float  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float  *Y, OPENBLAS_CONST blasint incY, float  *A, OPENBLAS_CONST blasint lda);
+void cblas_dger (OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double  alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
+void cblas_cgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void  *alpha, OPENBLAS_CONST void  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void  *Y, OPENBLAS_CONST blasint incY, void  *A, OPENBLAS_CONST blasint lda);
+void cblas_cgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void  *alpha, OPENBLAS_CONST void  *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void  *Y, OPENBLAS_CONST blasint incY, void  *A, OPENBLAS_CONST blasint lda);
+void cblas_zgeru(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
+void cblas_zgerc(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
 
-OPENBLAS_EXPORT void cblas_strsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_dtrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ctrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ztrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+void cblas_strsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dtrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+void cblas_ctrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+void cblas_ztrsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
 
-OPENBLAS_EXPORT void cblas_strmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_dtrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ctrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ztrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+void cblas_strmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
+void cblas_dtrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
+void cblas_ctrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
+void cblas_ztrmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
 
-OPENBLAS_EXPORT void cblas_ssyr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_dsyr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_cher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, void *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_zher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, void *A, OPENBLAS_CONST blasint lda);
+void cblas_ssyr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *A, OPENBLAS_CONST blasint lda);
+void cblas_dsyr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *A, OPENBLAS_CONST blasint lda);
+void cblas_cher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, void *A, OPENBLAS_CONST blasint lda);
+void cblas_zher(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, void *A, OPENBLAS_CONST blasint lda);
 
-OPENBLAS_EXPORT void cblas_ssyr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo,OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X,
+void cblas_ssyr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo,OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X,
                 OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_dsyr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X,
+void cblas_dsyr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X,
                 OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_cher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX,
+void cblas_cher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX,
                 OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
-OPENBLAS_EXPORT void cblas_zher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX,
+void cblas_zher2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX,
                 OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *A, OPENBLAS_CONST blasint lda);
 
-OPENBLAS_EXPORT void cblas_sgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_sgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_dgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_dgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_cgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_cgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_zgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_zgbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST blasint KL, OPENBLAS_CONST blasint KU, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
 
-OPENBLAS_EXPORT void cblas_ssbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A,
+void cblas_ssbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A,
                  OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_dsbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A,
+void cblas_dsbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A,
                  OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
 
 
-OPENBLAS_EXPORT void cblas_stbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_stbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_dtbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_dtbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ctbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_ctbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ztbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_ztbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
 
-OPENBLAS_EXPORT void cblas_stbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_stbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_dtbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_dtbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ctbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_ctbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ztbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_ztbsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *X, OPENBLAS_CONST blasint incX);
 
-OPENBLAS_EXPORT void cblas_stpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_stpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_dtpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_dtpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ctpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_ctpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST void *Ap, void *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ztpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_ztpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST void *Ap, void *X, OPENBLAS_CONST blasint incX);
 
-OPENBLAS_EXPORT void cblas_stpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_stpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST float *Ap, float *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_dtpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_dtpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST double *Ap, double *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ctpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_ctpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST void *Ap, void *X, OPENBLAS_CONST blasint incX);
-OPENBLAS_EXPORT void cblas_ztpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
+void cblas_ztpsv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_DIAG Diag,
                  OPENBLAS_CONST blasint N, OPENBLAS_CONST void *Ap, void *X, OPENBLAS_CONST blasint incX);
 
-OPENBLAS_EXPORT void cblas_ssymv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A,
+void cblas_ssymv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A,
                  OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_dsymv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A,
+void cblas_dsymv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A,
                  OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_chemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A,
+void cblas_chemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A,
                  OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_zhemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A,
+void cblas_zhemv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A,
                  OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
 
 
-OPENBLAS_EXPORT void cblas_sspmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *Ap,
+void cblas_sspmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *Ap,
                  OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float beta, float *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_dspmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *Ap,
+void cblas_dspmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *Ap,
                  OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double beta, double *Y, OPENBLAS_CONST blasint incY);
 
-OPENBLAS_EXPORT void cblas_sspr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *Ap);
-OPENBLAS_EXPORT void cblas_dspr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *Ap);
+void cblas_sspr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, float *Ap);
+void cblas_dspr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, double *Ap);
 
-OPENBLAS_EXPORT void cblas_chpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, void *A);
-OPENBLAS_EXPORT void cblas_zhpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST void *X,OPENBLAS_CONST blasint incX, void *A);
+void cblas_chpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, void *A);
+void cblas_zhpr(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST void *X,OPENBLAS_CONST blasint incX, void *A);
 
-OPENBLAS_EXPORT void cblas_sspr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *A);
-OPENBLAS_EXPORT void cblas_dspr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A);
-OPENBLAS_EXPORT void cblas_chpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *Ap);
-OPENBLAS_EXPORT void cblas_zhpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *Ap);
+void cblas_sspr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST float *Y, OPENBLAS_CONST blasint incY, float *A);
+void cblas_dspr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST double *Y, OPENBLAS_CONST blasint incY, double *A);
+void cblas_chpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *Ap);
+void cblas_zhpr2(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *Y, OPENBLAS_CONST blasint incY, void *Ap);
 
-OPENBLAS_EXPORT void cblas_chbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_chbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_zhbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_zhbmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
 
-OPENBLAS_EXPORT void cblas_chpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N,
+void cblas_chpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *Ap, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
-OPENBLAS_EXPORT void cblas_zhpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N,
+void cblas_zhpmv(OPENBLAS_CONST enum CBLAS_ORDER order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint N,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *Ap, OPENBLAS_CONST void *X, OPENBLAS_CONST blasint incX, OPENBLAS_CONST void *beta, void *Y, OPENBLAS_CONST blasint incY);
 
-OPENBLAS_EXPORT void cblas_sgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_sgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_dgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_dgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_cgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_cgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_cgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_cgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_zgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_zgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_zgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_zgemm3m(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
 
-OPENBLAS_EXPORT void cblas_sgemmt(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_dgemmt(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_cgemmt(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_zgemmt(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint K,
-		 OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
 
-OPENBLAS_EXPORT void cblas_ssymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_ssymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_dsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_dsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_csymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_csymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_zsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_zsymm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
 
-OPENBLAS_EXPORT void cblas_ssyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+void cblas_ssyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_dsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+void cblas_dsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_csyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+void cblas_csyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_zsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+void cblas_zsyrk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		 OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
 
-OPENBLAS_EXPORT void cblas_ssyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+void cblas_ssyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_dsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+void cblas_dsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, double *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_csyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+void cblas_csyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_zsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
+void cblas_zsyr2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans,
 		  OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
 
-OPENBLAS_EXPORT void cblas_strmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+void cblas_strmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
-OPENBLAS_EXPORT void cblas_dtrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+void cblas_dtrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
-OPENBLAS_EXPORT void cblas_ctrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+void cblas_ctrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *B, OPENBLAS_CONST blasint ldb);
-OPENBLAS_EXPORT void cblas_ztrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+void cblas_ztrmm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *B, OPENBLAS_CONST blasint ldb);
 
-OPENBLAS_EXPORT void cblas_strsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+void cblas_strsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *A, OPENBLAS_CONST blasint lda, float *B, OPENBLAS_CONST blasint ldb);
-OPENBLAS_EXPORT void cblas_dtrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+void cblas_dtrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *A, OPENBLAS_CONST blasint lda, double *B, OPENBLAS_CONST blasint ldb);
-OPENBLAS_EXPORT void cblas_ctrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+void cblas_ctrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *B, OPENBLAS_CONST blasint ldb);
-OPENBLAS_EXPORT void cblas_ztrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
+void cblas_ztrsm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA,
                  OPENBLAS_CONST enum CBLAS_DIAG Diag, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, void *B, OPENBLAS_CONST blasint ldb);
 
-OPENBLAS_EXPORT void cblas_chemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_chemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_zhemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
+void cblas_zhemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_SIDE Side, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N,
                  OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST void *beta, void *C, OPENBLAS_CONST blasint ldc);
 
-OPENBLAS_EXPORT void cblas_cherk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_cherk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
                  OPENBLAS_CONST float alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST float beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_zherk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_zherk(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
                  OPENBLAS_CONST double alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST double beta, void *C, OPENBLAS_CONST blasint ldc);
 
-OPENBLAS_EXPORT void cblas_cher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_cher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
                   OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, void *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_zher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void cblas_zher2k(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_UPLO Uplo, OPENBLAS_CONST enum CBLAS_TRANSPOSE Trans, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
                   OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST void *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST double beta, void *C, OPENBLAS_CONST blasint ldc);
 
-OPENBLAS_EXPORT void cblas_xerbla(blasint p, OPENBLAS_CONST char *rout, OPENBLAS_CONST char *form, ...);
+void cblas_xerbla(blasint p, char *rout, char *form, ...);
 
 /*** BLAS extensions ***/
 
-OPENBLAS_EXPORT void cblas_saxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST float beta, float *y, OPENBLAS_CONST blasint incy);
+void cblas_saxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST float *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST float beta, float *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT void cblas_daxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST double beta, double *y, OPENBLAS_CONST blasint incy);
+void cblas_daxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST double alpha, OPENBLAS_CONST double *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST double beta, double *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT void cblas_caxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST void *beta, void *y, OPENBLAS_CONST blasint incy);
+void cblas_caxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST void *beta, void *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT void cblas_zaxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST void *beta, void *y, OPENBLAS_CONST blasint incy);
+void cblas_zaxpby(OPENBLAS_CONST blasint n, OPENBLAS_CONST void *alpha, OPENBLAS_CONST void *x, OPENBLAS_CONST blasint incx,OPENBLAS_CONST void *beta, void *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT void cblas_somatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, OPENBLAS_CONST float *a, 
+void cblas_somatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, OPENBLAS_CONST float *a, 
 		     OPENBLAS_CONST blasint clda, float *b, OPENBLAS_CONST blasint cldb); 
-OPENBLAS_EXPORT void cblas_domatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double calpha, OPENBLAS_CONST double *a,
+void cblas_domatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double calpha, OPENBLAS_CONST double *a,
 		     OPENBLAS_CONST blasint clda, double *b, OPENBLAS_CONST blasint cldb); 
-OPENBLAS_EXPORT void cblas_comatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float* calpha, OPENBLAS_CONST float* a, 
+void cblas_comatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float* calpha, OPENBLAS_CONST float* a, 
 		     OPENBLAS_CONST blasint clda, float*b, OPENBLAS_CONST blasint cldb); 
-OPENBLAS_EXPORT void cblas_zomatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double* calpha, OPENBLAS_CONST double* a, 
+void cblas_zomatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double* calpha, OPENBLAS_CONST double* a, 
 		     OPENBLAS_CONST blasint clda,  double *b, OPENBLAS_CONST blasint cldb); 
 
-OPENBLAS_EXPORT void cblas_simatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, float *a, 
+void cblas_simatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, float *a, 
 		     OPENBLAS_CONST blasint clda, OPENBLAS_CONST blasint cldb); 
-OPENBLAS_EXPORT void cblas_dimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double calpha, double *a,
+void cblas_dimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double calpha, double *a,
 		     OPENBLAS_CONST blasint clda, OPENBLAS_CONST blasint cldb); 
-OPENBLAS_EXPORT void cblas_cimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float* calpha, float* a, 
+void cblas_cimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float* calpha, float* a, 
 		     OPENBLAS_CONST blasint clda, OPENBLAS_CONST blasint cldb); 
-OPENBLAS_EXPORT void cblas_zimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double* calpha, double* a, 
+void cblas_zimatcopy(OPENBLAS_CONST enum CBLAS_ORDER CORDER, OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS, OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double* calpha, double* a, 
 		     OPENBLAS_CONST blasint clda, OPENBLAS_CONST blasint cldb); 
 
-OPENBLAS_EXPORT void cblas_sgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS_A,OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS_C,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, OPENBLAS_CONST float *a, OPENBLAS_CONST blasint clda,OPENBLAS_CONST float cbeta, float *c, 
-                  OPENBLAS_CONST blasint cldc);
-OPENBLAS_EXPORT void cblas_dgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS_A,OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS_C,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double calpha, OPENBLAS_CONST double *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST double cbeta, 
-		  double *c, OPENBLAS_CONST blasint cldc); 
-OPENBLAS_EXPORT void cblas_cgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS_A,OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS_C,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float *calpha, OPENBLAS_CONST float *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST float *cbeta, 
+void cblas_sgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float calpha, float *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST float cbeta, 
 		  float *c, OPENBLAS_CONST blasint cldc); 
-OPENBLAS_EXPORT void cblas_zgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS_A,OPENBLAS_CONST enum CBLAS_TRANSPOSE CTRANS_C,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double *calpha, OPENBLAS_CONST double *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST double *cbeta, 
+void cblas_dgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double calpha, double *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST double cbeta, 
+		  double *c, OPENBLAS_CONST blasint cldc); 
+void cblas_cgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST float *calpha, float *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST float *cbeta, 
+		  float *c, OPENBLAS_CONST blasint cldc); 
+void cblas_zgeadd(OPENBLAS_CONST enum CBLAS_ORDER CORDER,OPENBLAS_CONST blasint crows, OPENBLAS_CONST blasint ccols, OPENBLAS_CONST double *calpha, double *a, OPENBLAS_CONST blasint clda, OPENBLAS_CONST double *cbeta, 
 		  double *c, OPENBLAS_CONST blasint cldc); 
-
-OPENBLAS_EXPORT void cblas_sgemm_batch(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransA_array, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransB_array, OPENBLAS_CONST blasint * M_array, OPENBLAS_CONST blasint * N_array, OPENBLAS_CONST blasint * K_array,
-		       OPENBLAS_CONST float * alpha_array, OPENBLAS_CONST float ** A_array, OPENBLAS_CONST blasint * lda_array, OPENBLAS_CONST float ** B_array, OPENBLAS_CONST blasint * ldb_array, OPENBLAS_CONST float * beta_array, float ** C_array, OPENBLAS_CONST blasint * ldc_array, OPENBLAS_CONST blasint group_count, OPENBLAS_CONST blasint * group_size);
-
-OPENBLAS_EXPORT void cblas_dgemm_batch(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransA_array, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransB_array, OPENBLAS_CONST blasint * M_array, OPENBLAS_CONST blasint * N_array, OPENBLAS_CONST blasint * K_array,
-		       OPENBLAS_CONST double * alpha_array, OPENBLAS_CONST double ** A_array, OPENBLAS_CONST blasint * lda_array, OPENBLAS_CONST double ** B_array, OPENBLAS_CONST blasint * ldb_array, OPENBLAS_CONST double * beta_array, double ** C_array, OPENBLAS_CONST blasint * ldc_array, OPENBLAS_CONST blasint group_count, OPENBLAS_CONST blasint * group_size);
-
-OPENBLAS_EXPORT void cblas_cgemm_batch(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransA_array, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransB_array, OPENBLAS_CONST blasint * M_array, OPENBLAS_CONST blasint * N_array, OPENBLAS_CONST blasint * K_array,
-		       OPENBLAS_CONST void * alpha_array, OPENBLAS_CONST void ** A_array, OPENBLAS_CONST blasint * lda_array, OPENBLAS_CONST void ** B_array, OPENBLAS_CONST blasint * ldb_array, OPENBLAS_CONST void * beta_array, void ** C_array, OPENBLAS_CONST blasint * ldc_array, OPENBLAS_CONST blasint group_count, OPENBLAS_CONST blasint * group_size);
-
-OPENBLAS_EXPORT void cblas_zgemm_batch(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransA_array, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransB_array, OPENBLAS_CONST blasint * M_array, OPENBLAS_CONST blasint * N_array, OPENBLAS_CONST blasint * K_array,
-		       OPENBLAS_CONST void * alpha_array, OPENBLAS_CONST void ** A_array, OPENBLAS_CONST blasint * lda_array, OPENBLAS_CONST void ** B_array, OPENBLAS_CONST blasint * ldb_array, OPENBLAS_CONST void * beta_array, void ** C_array, OPENBLAS_CONST blasint * ldc_array, OPENBLAS_CONST blasint group_count, OPENBLAS_CONST blasint * group_size);
-
-OPENBLAS_EXPORT void cblas_sgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST float * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST float * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST float beta, float * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
-
-OPENBLAS_EXPORT void cblas_dgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST double alpha, OPENBLAS_CONST double * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST double * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST double beta, double * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
-
-OPENBLAS_EXPORT void cblas_cgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void * alpha, OPENBLAS_CONST void * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST void * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST void * beta, void * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
-
-OPENBLAS_EXPORT void cblas_zgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST void * alpha, OPENBLAS_CONST void * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST void * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST void * beta, void * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
 
 /*** BFLOAT16 and INT8 extensions ***/
 /* convert float array to BFLOAT16 array by rounding */
-OPENBLAS_EXPORT void   cblas_sbstobf16(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *in, OPENBLAS_CONST blasint incin, bfloat16 *out, OPENBLAS_CONST blasint incout);
+void   cblas_sbstobf16(OPENBLAS_CONST blasint n, OPENBLAS_CONST float  *in, OPENBLAS_CONST blasint incin, bfloat16 *out, OPENBLAS_CONST blasint incout);
 /* convert double array to BFLOAT16 array by rounding */
-OPENBLAS_EXPORT void   cblas_sbdtobf16(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *in, OPENBLAS_CONST blasint incin, bfloat16 *out, OPENBLAS_CONST blasint incout);
+void   cblas_sbdtobf16(OPENBLAS_CONST blasint n, OPENBLAS_CONST double *in, OPENBLAS_CONST blasint incin, bfloat16 *out, OPENBLAS_CONST blasint incout);
 /* convert BFLOAT16 array to float array */
-OPENBLAS_EXPORT void   cblas_sbf16tos(OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 *in, OPENBLAS_CONST blasint incin, float  *out, OPENBLAS_CONST blasint incout);
+void   cblas_sbf16tos(OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 *in, OPENBLAS_CONST blasint incin, float  *out, OPENBLAS_CONST blasint incout);
 /* convert BFLOAT16 array to double array */
-OPENBLAS_EXPORT void   cblas_dbf16tod(OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 *in, OPENBLAS_CONST blasint incin, double *out, OPENBLAS_CONST blasint incout);
-OPENBLAS_EXPORT void   cblas_bgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 alpha, OPENBLAS_CONST bfloat16 *a, OPENBLAS_CONST blasint lda, OPENBLAS_CONST bfloat16 *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST bfloat16 beta, bfloat16 *y, OPENBLAS_CONST blasint incy);
+void   cblas_dbf16tod(OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 *in, OPENBLAS_CONST blasint incin, double *out, OPENBLAS_CONST blasint incout);
 /* dot production of BFLOAT16 input arrays, and output as float */
-OPENBLAS_EXPORT float  cblas_sbdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST bfloat16 *y, OPENBLAS_CONST blasint incy);
-OPENBLAS_EXPORT void   cblas_sbgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST bfloat16 *a, OPENBLAS_CONST blasint lda, OPENBLAS_CONST bfloat16 *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float beta, float *y, OPENBLAS_CONST blasint incy);
+float  cblas_sbdot(OPENBLAS_CONST blasint n, OPENBLAS_CONST bfloat16 *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST bfloat16 *y, OPENBLAS_CONST blasint incy);
+void   cblas_sbgemv(OPENBLAS_CONST enum CBLAS_ORDER order,  OPENBLAS_CONST enum CBLAS_TRANSPOSE trans,  OPENBLAS_CONST blasint m, OPENBLAS_CONST blasint n, OPENBLAS_CONST float alpha, OPENBLAS_CONST bfloat16 *a, OPENBLAS_CONST blasint lda, OPENBLAS_CONST bfloat16 *x, OPENBLAS_CONST blasint incx, OPENBLAS_CONST float beta, float *y, OPENBLAS_CONST blasint incy);
 
-OPENBLAS_EXPORT void cblas_bgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-		    OPENBLAS_CONST bfloat16 alpha, OPENBLAS_CONST bfloat16 *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST bfloat16 *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST bfloat16 beta, bfloat16 *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_sbgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
+void   cblas_sbgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
 		    OPENBLAS_CONST float alpha, OPENBLAS_CONST bfloat16 *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST bfloat16 *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
-OPENBLAS_EXPORT void cblas_sbgemm_batch(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransA_array, OPENBLAS_CONST enum CBLAS_TRANSPOSE * TransB_array, OPENBLAS_CONST blasint * M_array, OPENBLAS_CONST blasint * N_array, OPENBLAS_CONST blasint * K_array,
-		       OPENBLAS_CONST float * alpha_array, OPENBLAS_CONST bfloat16 ** A_array, OPENBLAS_CONST blasint * lda_array, OPENBLAS_CONST bfloat16 ** B_array, OPENBLAS_CONST blasint * ldb_array, OPENBLAS_CONST float * beta_array, float ** C_array, OPENBLAS_CONST blasint * ldc_array, OPENBLAS_CONST blasint group_count, OPENBLAS_CONST blasint * group_size);
-
-OPENBLAS_EXPORT void cblas_sbgemm_batch_strided(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K, OPENBLAS_CONST float alpha, OPENBLAS_CONST bfloat16 * A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST blasint stridea, OPENBLAS_CONST bfloat16 * B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST blasint strideb, OPENBLAS_CONST float beta, float * C, OPENBLAS_CONST blasint ldc, OPENBLAS_CONST blasint stridec, OPENBLAS_CONST blasint group_size);
-/*** FLOAT16 extensions ***/
-OPENBLAS_EXPORT void cblas_shgemm(OPENBLAS_CONST enum CBLAS_ORDER Order, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransA, OPENBLAS_CONST enum CBLAS_TRANSPOSE TransB, OPENBLAS_CONST blasint M, OPENBLAS_CONST blasint N, OPENBLAS_CONST blasint K,
-		    OPENBLAS_CONST float alpha, OPENBLAS_CONST hfloat16 *A, OPENBLAS_CONST blasint lda, OPENBLAS_CONST hfloat16 *B, OPENBLAS_CONST blasint ldb, OPENBLAS_CONST float beta, float *C, OPENBLAS_CONST blasint ldc);
-
 #ifdef __cplusplus
 }
 #endif  /* __cplusplus */

cmake/OpenBLASConfig.cmake.in

@@ -50,30 +50,30 @@ set(PN OpenBLAS)
 
 # need to check that the @USE_*@ evaluate to something cmake can perform boolean logic upon
 if(@USE_OPENMP@)
-    set(${PN}@SUFFIX64@_openmp_FOUND 1)
+    set(${PN}_openmp_FOUND 1)
 elseif(@USE_THREAD@)
-    set(${PN}@SUFFIX64@_pthread_FOUND 1)
+    set(${PN}_pthread_FOUND 1)
 else()
-    set(${PN}@SUFFIX64@_serial_FOUND 1)
+    set(${PN}_serial_FOUND 1)
 endif()
 
-check_required_components(${PN}@SUFFIX64@)
+check_required_components(${PN})
 
 #-----------------------------------------------------------------------------
 # Don't include targets if this file is being picked up by another
 # project which has already built this as a subproject
 #-----------------------------------------------------------------------------
-if(NOT TARGET ${PN}@SUFFIX64@::OpenBLAS)
-    include("${CMAKE_CURRENT_LIST_DIR}/${PN}@SUFFIX64@Targets.cmake")
+if(NOT TARGET ${PN}::OpenBLAS)
+    include("${CMAKE_CURRENT_LIST_DIR}/${PN}Targets.cmake")
 
-    get_property(_loc TARGET ${PN}@SUFFIX64@::OpenBLAS PROPERTY LOCATION)
-    set(${PN}@SUFFIX64@_LIBRARY ${_loc})
-    get_property(_ill TARGET ${PN}@SUFFIX64@::OpenBLAS PROPERTY INTERFACE_LINK_LIBRARIES)
-    set(${PN}@SUFFIX64@_LIBRARIES ${_ill})
+    get_property(_loc TARGET ${PN}::OpenBLAS PROPERTY LOCATION)
+    set(${PN}_LIBRARY ${_loc})
+    get_property(_ill TARGET ${PN}::OpenBLAS PROPERTY INTERFACE_LINK_LIBRARIES)
+    set(${PN}_LIBRARIES ${_ill})
 
-    get_property(_id TARGET ${PN}@SUFFIX64@::OpenBLAS PROPERTY INCLUDE_DIRECTORIES)
-    set(${PN}@SUFFIX64@_INCLUDE_DIR ${_id})
-    get_property(_iid TARGET ${PN}@SUFFIX64@::OpenBLAS PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
-    set(${PN}@SUFFIX64@_INCLUDE_DIRS ${_iid})
+    get_property(_id TARGET ${PN}::OpenBLAS PROPERTY INCLUDE_DIRECTORIES)
+    set(${PN}_INCLUDE_DIR ${_id})
+    get_property(_iid TARGET ${PN}::OpenBLAS PROPERTY INTERFACE_INCLUDE_DIRECTORIES)
+    set(${PN}_INCLUDE_DIRS ${_iid})
 endif()
 

cmake/arch.cmake

@@ -31,46 +31,22 @@ if (${CMAKE_C_COMPILER_ID} STREQUAL "Intel")
   set(CCOMMON_OPT "${CCOMMON_OPT} -wd981")
 endif ()
 
+if (USE_OPENMP)
+  # USE_SIMPLE_THREADED_LEVEL3 = 1
+  # NO_AFFINITY = 1
+  find_package(OpenMP REQUIRED)
+  if (OpenMP_FOUND)
+    set(CCOMMON_OPT "${CCOMMON_OPT} ${OpenMP_C_FLAGS} -DUSE_OPENMP")
+    set(FCOMMON_OPT "${FCOMMON_OPT} ${OpenMP_Fortran_FLAGS}")
+  endif()
+endif ()
+
+
 if (DYNAMIC_ARCH)
   if (ARM64)
-    set(DYNAMIC_CORE ARMV8 CORTEXA53 CORTEXA57 THUNDERX THUNDERX2T99 TSV110 EMAG8180 NEOVERSEN1 THUNDERX3T110)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 10) # SVE ACLE supported in GCC >= 10
-        set(DYNAMIC_CORE ${DYNAMIC_CORE} NEOVERSEV1 NEOVERSEN2 ARMV8SVE A64FX)
-      endif ()
-      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 14) # SME ACLE supported in GCC >= 14
-        set(DYNAMIC_CORE ${DYNAMIC_CORE} ARMV9SME)
-      endif()
-	  if (${CMAKE_C_COMPILER_ID} MATCHES "Clang" AND ${CMAKE_SYSTEM_NAME} STREQUAL "Darwin")
-	    set(DYNAMIC_CORE ${DYNAMIC_CORE} VORTEXM4)
-      endif()
-    elseif (${CMAKE_C_COMPILER_ID} MATCHES "Clang")
-      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 11) # SVE ACLE supported in LLVM >= 11
-        set(DYNAMIC_CORE ${DYNAMIC_CORE} NEOVERSEV1 NEOVERSEN2 ARMV8SVE A64FX)
-      endif ()
-	  if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 17) # SME ACLE supported in LLVM >= 17
-        set(DYNAMIC_CORE ${DYNAMIC_CORE} ARMV9SME)
-      endif()
-
-	  if (NOT ${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 19 OR (${CMAKE_C_COMPILER_ID} MATCHES AppleClang AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 17) ) # SME w/out SVE supported in LLVM >= 19 and AppleClang >= 17
-        set(DYNAMIC_CORE ${DYNAMIC_CORE} VORTEXM4)
-      endif()
-	  endif()
-    endif ()
-
-    if (${CMAKE_SYSTEM_NAME} STREQUAL "Darwin" OR ${CMAKE_SYSTEM_NAME} STREQUAL "iOS")
-      set(DYNAMIC_CORE ARMV8 NEOVERSEN1)
-      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 19 OR (${CMAKE_C_COMPILER_ID} MATCHES AppleClang AND ${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 17) ) # SME ACLE supported in LLVM >= 19 and AppleClang >= 17
-        set(DYNAMIC_CORE ${DYNAMIC_CORE} VORTEXM4)
-      endif()
-      if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER_EQUAL 14) # SME ACLE supported in GCC >= 14
-        set(DYNAMIC_CORE ${DYNAMIC_CORE} ARMV9SME)
-      endif()
-    endif()
-    
+	  set(DYNAMIC_CORE ARMV8 CORTEXA53 CORTEXA55 CORTEXA57 CORTEXA72 CORTEXA73 FALKOR THUNDERX THUNDERX2T99 TSV110 EMAG8180 NEOVERSEN1 NEOVERSEV1 NEOVERSEN2 THUNDERX3T110)
     if (DYNAMIC_LIST)
-	  set(DYNAMIC_CORE ARMV8 ${DYNAMIC_LIST})
+	    set(DYNAMIC_CORE ARMV8 ${DYNAMIC_LIST})
     endif ()
   endif ()
   
@@ -78,11 +54,7 @@ if (DYNAMIC_ARCH)
 	  set(DYNAMIC_CORE POWER6 POWER8 POWER9 POWER10)
 	  set(CCOMMON_OPT "${CCOMMON_OPT} -DHAVE_P10_SUPPORT")
   endif ()
- 
-  if (RISCV64)
-	  set(DYNAMIC_CORE RISCV64_GENERIC RISCV64_ZVL128B RISCV64_ZVL256B) 
-  endif ()
-
+  
   if (X86)
     set(DYNAMIC_CORE KATMAI COPPERMINE NORTHWOOD PRESCOTT BANIAS CORE2 PENRYN DUNNINGTON NEHALEM ATHLON OPTERON OPTERON_SSE3 BARCELONA BOBCAT ATOM NANO)
   endif ()
@@ -107,23 +79,13 @@ if (DYNAMIC_ARCH)
       set(DYNAMIC_CORE ${DYNAMIC_CORE} HASWELL ZEN)
     endif ()
     if (NOT NO_AVX512)
-      set(DYNAMIC_CORE ${DYNAMIC_CORE} SKYLAKEX COOPERLAKE SAPPHIRERAPIDS)
+      set(DYNAMIC_CORE ${DYNAMIC_CORE} SKYLAKEX COOPERLAKE)
       string(REGEX REPLACE "-march=native" "" CMAKE_C_FLAGS "${CMAKE_C_FLAGS}")
     endif ()
     if (DYNAMIC_LIST)
       set(DYNAMIC_CORE PRESCOTT ${DYNAMIC_LIST})
     endif ()
   endif ()
-  
-  if (ZARCH)
-    set(DYNAMIC_CORE Z13 Z14 ZARCH_GENERIC)
-    set(DYN_Z13 1)
-	set(DYN_Z14 1)
-  endif ()
-  
-  if (LOONGARCH64)
-    set(DYNAMIC_CORE LA64_GENERIC LA264 LA464)
-  endif ()
 
   if (EXISTS ${PROJECT_SOURCE_DIR}/config_kernel.h)
 	  message (FATAL_ERROR "Your build directory contains a file config_kernel.h, probably from a previous compilation with make. This will conflict with the cmake compilation and cause strange compiler errors - please remove the file before trying again")
@@ -170,8 +132,3 @@ if (ARM64)
   set(BINARY_DEFINED 1)
 endif ()
 
-if (RISCV64)
-  set(NO_BINARY_MODE 1)
-  set(BINARY_DEFINED 1)
-endif ()
-

cmake/cc.cmake

@@ -1,46 +1,13 @@
-###############################################################################
-# Copyright (c) 2025, The OpenBLAS Project
-# All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. 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.
-# 3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-###############################################################################
 ##
 ## Author: Hank Anderson <hank@statease.com>
 ## Description: Ported from portion of OpenBLAS/Makefile.system
 ##              Sets C related variables.
-include(CheckCCompilerFlag)
-
-if (${CMAKE_C_COMPILER_ID} MATCHES "IntelLLVM")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -fp-model=consistent")
-  set(GCC_VERSION 100)
-endif ()
 
 if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_C_COMPILER_ID} STREQUAL "LSB" OR ${CMAKE_C_COMPILER_ID} MATCHES "Clang")
+
   set(CCOMMON_OPT "${CCOMMON_OPT} -Wall")
   set(COMMON_PROF "${COMMON_PROF} -fno-inline")
   set(NO_UNINITIALIZED_WARN "-Wno-uninitialized")
-  set(GCC_VERSION ${CMAKE_C_COMPILER_VERSION})
 
   if (QUIET_MAKE)
     set(CCOMMON_OPT "${CCOMMON_OPT} ${NO_UNINITIALIZED_WARN} -Wno-unused")
@@ -69,27 +36,13 @@ if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU" OR ${CMAKE_C_COMPILER_ID} STREQUAL "LS
 
     if (LOONGARCH64)
       if (BINARY64)
-	CHECK_C_COMPILER_FLAG("-mabi=lp64d" COMPILER_SUPPORT_LP64D_ABI)
-        if(COMPILER_SUPPORT_LP64D_ABI)
-	  set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=lp64d")
-	else()
-	  set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=lp64")
-	endif ()
+        set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=lp64")
       else ()
-	CHECK_C_COMPILER_FLAG("-mabi=ilp32d" COMPILER_SUPPORT_ILP32D_ABI)
-	if(COMPILER_SUPPORT_ILP32D_ABI)
-	  set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=ilp32d")
-	else()
-	  set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=lp32")
-	endif ()
+        set(CCOMMON_OPT "${CCOMMON_OPT} -mabi=lp32")
       endif ()
       set(BINARY_DEFINED 1)
     endif ()
 
-    if (ZARCH)
-      set (BINARY_DEFINED 1)
-	endif ()
- 
     if (CMAKE_SYSTEM_NAME STREQUAL "AIX")
       set(BINARY_DEFINED 1)
     endif ()
@@ -112,15 +65,6 @@ if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI")
   endif ()
 endif ()
 
-if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC")
-  set (GCC_VERSION 100)
-  if (POWER)
-    set(CCOMMON_OPT "${CCOMMON_OPT} -tp pwr8")
-  elseif (X86_64)
-    set(CCOMMON_OPT "${CCOMMON_OPT} -tp px")
-  endif ()
-endif ()
-
 if (${CMAKE_C_COMPILER_ID} STREQUAL "PATHSCALE")
   if (BINARY64)
     set(CCOMMON_OPT "${CCOMMON_OPT} -m64")
@@ -177,6 +121,7 @@ endif ()
 if (${CORE} STREQUAL COOPERLAKE)
   if (NOT DYNAMIC_ARCH)
     if (NOT NO_AVX512)
+      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
       if (${GCC_VERSION} VERSION_GREATER 10.1 OR ${GCC_VERSION} VERSION_EQUAL 10.1)
         set (CCOMMON_OPT  "${CCOMMON_OPT} -march=cooperlake")
       else ()
@@ -189,6 +134,7 @@ endif ()
 if (${CORE} STREQUAL SAPPHIRERAPIDS)
   if (NOT DYNAMIC_ARCH)
     if (NOT NO_AVX512)
+      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
       if (${GCC_VERSION} VERSION_GREATER 11.0 OR ${GCC_VERSION} VERSION_EQUAL 11.0)
         set (CCOMMON_OPT  "${CCOMMON_OPT} -march=sapphirerapids")
       else ()
@@ -198,25 +144,10 @@ if (${CORE} STREQUAL SAPPHIRERAPIDS)
   endif ()
 endif ()
 
-if (${CORE} STREQUAL ZEN)
-  if (HAVE_AVX512VL)
-    if (NOT DYNAMIC_ARCH)
-      if (NOT NO_AVX512)
-        if (${GCC_VERSION} VERSION_GREATER 13.0 OR ${GCC_VERSION} VERSION_EQUAL 13.0)
-          set (CCOMMON_OPT  "${CCOMMON_OPT} -march=znver4")
-        else ()
-          set (CCOMMON_OPT "${CCOMMON_OPT} -march=skylake-avx512")
-        endif ()
-      endif ()
-    endif ()
-  endif ()
-endif ()
-
 if (${CORE} STREQUAL A64FX)
   if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=a64fx")
-    elseif (${GCC_VERSION} VERSION_GREATER 11.0 OR ${GCC_VERSION} VERSION_EQUAL 11.0)
+    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+    if (${GCC_VERSION} VERSION_GREATER 11.0 OR ${GCC_VERSION} VERSION_EQUAL 11.0)
       set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.2-a+sve -mtune=a64fx")
     else ()
       set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.2-a+sve")
@@ -224,160 +155,31 @@ if (${CORE} STREQUAL A64FX)
   endif ()
 endif ()
 
-if (${CORE} STREQUAL NEOVERSEV2)
-	if (NOT DYNAMIC_ARCH)
-		if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
-			set (CCOMMON_OPT  "${CCOMMON_OPT} -Msve_intrinsics -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-v2")
-		elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
-			set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-v2")
-		else ()
-			if (${GCC_VERSION} VERSION_GREATER 13.0 OR ${GCC_VERSION} VERSION_EQUAL 13.0)
-				set (CCOMMON_OPT  "${CCOMMON_OPT} -mcpu=neoverse-v2")
-			elseif (${GCC_VERSION} VERSION_GREATER 10.4 OR ${GCC_VERSION} VERSION_EQUAL 10.4)
-				set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.4-a+sve+bf16 -mtune=neoverse-v1")
-			else ()
-				set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.2-a+sve+bf16")
-			endif()
-		endif ()
-	endif ()
-endif ()
-
-if (${CORE} STREQUAL NEOVERSEN2)
-  if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -Msve_intrinsics -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-n2")
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-v2")
-    else ()
-      if (${GCC_VERSION} VERSION_GREATER 11.1 OR ${GCC_VERSION} VERSION_EQUAL 11.1)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-n2")
-      else ()
-	set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.2-a+sve+bf16")
-      endif()
-    endif ()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL NEOVERSEV1)
-  if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -Msve_intrinsics -march=armv8.4-a+sve+bf16 -mtune=neoverse-v1")
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-v1")
-    else ()
-      if (${GCC_VERSION} VERSION_GREATER 10.4 OR ${GCC_VERSION} VERSION_EQUAL 10.4)
-        set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.4-a+sve+bf16 -mtune=neoverse-v1")
-      else ()
-        set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.2-a+sve+bf16")
-      endif()
-    endif()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL NEOVERSEN1)
-  if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-n1")
-    elseif (${GCC_VERSION} VERSION_GREATER 9.4 OR ${GCC_VERSION} VERSION_EQUAL 9.4)
-      set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.2-a -mtune=neoverse-n1")
-    else ()
-      set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.2-a")
-    endif()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL AMPEREONE)
-  if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC")
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=neoverse-n1")
-    elseif (${GCC_VERSION} VERSION_GREATER 12.1)
-      set (CCOMMON_OPT  "${CCOMMON_OPT} -march=armv8.6-a+crypto+crc+fp16+sha3+rng -mtune=ampereone")
-    else ()
-      set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.6-a+fp16")
-    endif()
-  endif ()
-endif ()
-
 if (${CORE} STREQUAL ARMV8SVE)
   if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
-	set (CCOMMON_OPT  "${CCOMMON_OPT} -Msve_intrinsics -march=armv8-a+sve")
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
-	    set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=host")
-    else ()
-      set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8-a+sve")
-    endif ()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL ARMV9SME)
-  if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC" AND NOT NO_SVE)
-      set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=host")
-    else ()
-      set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv9-a+sme+sme-f64f64")
-      if (CMAKE_SYSTEM_NAME STREQUAL "Windows" AND CMAKE_C_COMPILER_ID MATCHES "Clang")
-        set (CCOMMON_OPT "${CCOMMON_OPT} -mllvm --aarch64-stack-hazard-size=0")
-      endif ()
-    endif ()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL VORTEXM4)
-  if (NOT DYNAMIC_ARCH)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "NVC" AND NOT NO_SVE)
-	    set (CCOMMON_OPT  "${CCOMMON_OPT} -tp=host")
-    else ()
-	  if (${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang")
-        set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.4-a+sme+sme-f64f64 -mcpu=apple-m4")
-	  else ()
-	    set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.4-a -mcpu=apple-m4")
-      endif ()
-	endif ()
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL CORTEXA510)
-  if (NOT DYNAMIC_ARCH)
-    set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.4-a+sve")
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL CORTEXA710)
-  if (NOT DYNAMIC_ARCH)
-    set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.4-a+sve")
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL CORTEXX1)
-  if (NOT DYNAMIC_ARCH)
-    set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.2-a")
-  endif ()
-endif ()
-
-if (${CORE} STREQUAL CORTEXX2)
-  if (NOT DYNAMIC_ARCH)
-    set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8.4-a+sve")
+    set (CCOMMON_OPT "${CCOMMON_OPT} -march=armv8-a+sve")
   endif ()
 endif ()
 
 if (${CORE} STREQUAL POWER10)
   if (NOT DYNAMIC_ARCH)
+    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
     if (${GCC_VERSION} VERSION_GREATER 10.2 OR ${GCC_VERSION} VERSION_EQUAL 10.2)
       set (CCOMMON_OPT  "${CCOMMON_OPT} -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math")
     else ()
-      message(FATAL_ERROR "Compiler GCC ${GCC_VERSION} does not support Power10." )
+      message(FATAL_ERROR "Compiler GCC.${GCC_VERSION} does not support Power10." )
     endif()
   endif ()
 endif ()
 
 if (${CORE} STREQUAL POWER9)
   if (NOT DYNAMIC_ARCH)
+    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
     if (${GCC_VERSION} VERSION_GREATER 5.0 OR ${GCC_VERSION} VERSION_EQUAL 5.0)
       set (CCOMMON_OPT  "${CCOMMON_OPT} -mcpu=power9 -mtune=power9 -mvsx -fno-fast-math")
     else ()
       set (CCOMMON_OPT  "${CCOMMON_OPT} -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math")
-      message(WARNING "Compiler GCC ${GCC_VERSION} does not fully support Power9.")
+      message(WARNING "Compiler GCC.${GCC_VERSION} does not fully support Power9.")
     endif ()
   endif ()
 endif ()
@@ -388,54 +190,6 @@ if (${CORE} STREQUAL POWER8)
   endif ()
 endif ()
 
-# With -mcpu=970 added it compiles, but library is broken, at least on macOS. If someone
-# tests on *BSD or Linux and adds this flag, please make sure it is not used for macOS case.
-if (${CORE} STREQUAL PPC970)
-  if (NOT DYNAMIC_ARCH)
-    set (CCOMMON_OPT  "${CCOMMON_OPT} -mtune=970 -maltivec -fno-fast-math")
-  endif ()
-  if (APPLE)
-    set (CCOMMON_OPT  "${CCOMMON_OPT} -force_cpusubtype_ALL")
-  endif ()
-endif ()
-
-# -mcpu=G4 seems to work fine, but perhaps avoid it for the sake of consistency?
-if (${CORE} STREQUAL PPCG4)
-  if (NOT DYNAMIC_ARCH)
-    set (CCOMMON_OPT  "${CCOMMON_OPT} -mtune=G4 -maltivec -fno-fast-math")
-  endif ()
-  if (APPLE)
-    set (CCOMMON_OPT  "${CCOMMON_OPT} -force_cpusubtype_ALL")
-  endif ()
-endif ()
-
-
-if ((${CORE} STREQUAL RISCV64_ZVL128B) OR (${CORE} STREQUAL RISCV64_ZVL256B))
-  set (RISCV64_OPT "rv64imafdcv")
-  if (BUILD_BFLOAT16)
-    set (RISCV64_OPT "${RISCV64_OPT}_zvfbfwma")
-  endif()
-  if (BUILD_HFLOAT16)
-    set (RISCV64_OPT "${RISCV64_OPT}_zvfh_zfh")
-  endif()
-  if (${CORE} STREQUAL RISCV64_ZVL256B)
-    set (CCOMMON_OPT "${CCOMMON_OPT} -march=${RISCV64_OPT}_zvl256b -mabi=lp64d")
-  endif()
-  if (${CORE} STREQUAL RISCV64_ZVL128B)
-    set (CCOMMON_OPT "${CCOMMON_OPT} -march=${RISCV64_OPT}_zvl128b -mabi=lp64d")
-  endif()
-endif()
-if (${CORE} STREQUAL RISCV64_GENERIC)
-  set (CCOMMON_OPT "${CCOMMON_OPT} -march=rv64imafdc -mabi=lp64d")
-endif()
-if (${CORE} STREQUAL U74)
-  set (CCOMMON_OPT "${CCOMMON_OPT} -march=rv64imafdc_zba_zbb -mabi=lp64d -mtune=sifive-u74")
-endif()
-if (${CORE} STREQUAL x280)
-  set (CCOMMON_OPT "${CCOMMON_OPT} -march=rv64imafdcv_zba_zbb_zfh_zvl512b -mabi=lp64d")
-endif()
-
-
 if (NOT DYNAMIC_ARCH)
 	if (HAVE_AVX2)
         set (CCOMMON_OPT  "${CCOMMON_OPT} -mavx2")

cmake/export.cmake

@@ -50,15 +50,6 @@ else()
   set(ONLY_CBLAS_IN ${ONLY_CBLAS})
 endif()
 
-if (NOT DEFINED USE_PERL)
-add_custom_command(
-  OUTPUT ${PROJECT_BINARY_DIR}/openblas.def
-  #TARGET ${OpenBLAS_LIBNAME} PRE_LINK
-  COMMAND "${PROJECT_SOURCE_DIR}/exports/gensymbol"
-  ARGS "win2k" "${ARCH_IN}" "dummy" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" "${SYMBOLPREFIX}" "${SYMBOLSUFFIX}" > "${PROJECT_BINARY_DIR}/openblas.def"
-  COMMENT "Create openblas.def file"
-  VERBATIM)
-else
 add_custom_command(
   OUTPUT ${PROJECT_BINARY_DIR}/openblas.def
   #TARGET ${OpenBLAS_LIBNAME} PRE_LINK
@@ -66,5 +57,5 @@ add_custom_command(
   ARGS "${PROJECT_SOURCE_DIR}/exports/gensymbol" "win2k" "${ARCH_IN}" "dummy" "${EXPRECISION_IN}" "${NO_CBLAS_IN}" "${NO_LAPACK_IN}" "${NO_LAPACKE_IN}" "${NEED2UNDERSCORES_IN}" "${ONLY_CBLAS_IN}" "${SYMBOLPREFIX}" "${SYMBOLSUFFIX}" > "${PROJECT_BINARY_DIR}/openblas.def"
   COMMENT "Create openblas.def file"
   VERBATIM)
-endif()
+
 endif()

cmake/f_check.cmake

@@ -25,19 +25,11 @@ check_language(Fortran)
 if(CMAKE_Fortran_COMPILER)
   enable_language(Fortran)
 else()
-  set (NOFORTRAN 1)
   if (NOT NO_LAPACK)
-     if (NOT XXXXX)
-	message(STATUS "No Fortran compiler found, can build only BLAS and f2c-converted LAPACK")
-	set(C_LAPACK 1)
-	if (INTERFACE64)
-	  set (CCOMMON_OPT "${CCOMMON_OPT} -DLAPACK_ILP64")
-  	endif ()
-	set(TIMER "NONE")
-     else ()
-       message(STATUS "No Fortran compiler found, can build only BLAS")
-     endif()  
+    message(STATUS "No Fortran compiler found, can build only BLAS but not LAPACK")
   endif()
+  set (NOFORTRAN 1)
+  set (NO_LAPACK 1)
 endif()
 
 if (NOT ONLY_CBLAS)
@@ -45,15 +37,13 @@ if (NOT ONLY_CBLAS)
 
   # TODO: detect whether underscore needed, set #defines and BU appropriately - use try_compile
   # TODO: set FEXTRALIB flags a la f_check?
-  if (NOT (${CMAKE_SYSTEM_NAME} MATCHES "Windows" AND x${CMAKE_Fortran_COMPILER_ID} MATCHES "IntelLLVM"))
+
   set(BU "_")
   file(APPEND ${TARGET_CONF_TEMP}
     "#define BUNDERSCORE _\n"
     "#define NEEDBUNDERSCORE 1\n"
     "#define NEED2UNDERSCORES 0\n")
-  else ()
-	  set (FCOMMON_OPT "${FCOMMON_OPT} /fp:precise /recursive /names:lowercase /assume:nounderscore")
-  endif()
+
 else ()
 
   #When we only build CBLAS, we set NOFORTRAN=2
@@ -66,7 +56,6 @@ else ()
     "#define NEEDBUNDERSCORE 1\n")
 endif()
 
-if (CMAKE_Fortran_COMPILER)
 get_filename_component(F_COMPILER ${CMAKE_Fortran_COMPILER} NAME_WE)
 string(TOUPPER ${F_COMPILER} F_COMPILER)
-endif()
+

cmake/fc.cmake

@@ -3,11 +3,13 @@
 ## Description: Ported from portion of OpenBLAS/Makefile.system
 ##              Sets Fortran related variables.
 
-if (${F_COMPILER} STREQUAL "FLANG" AND NOT CMAKE_Fortran_COMPILER_ID STREQUAL "LLVMFlang")
-  # This is for classic Flang. LLVM Flang is handled with gfortran below.
+if (${F_COMPILER} STREQUAL "FLANG")
   set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_FLANG")
+  if (BINARY64 AND INTERFACE64)
+    set(FCOMMON_OPT "${FCOMMON_OPT} -i8")
+  endif ()
   if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-fopenmp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -fopenmp")
   endif ()
   set(FCOMMON_OPT "${FCOMMON_OPT} -Mrecursive -Kieee")
 endif ()
@@ -36,106 +38,62 @@ if (${F_COMPILER} STREQUAL "G95")
   endif ()
 endif ()
 
-if (${F_COMPILER} STREQUAL "GFORTRAN" OR ${F_COMPILER} STREQUAL "F95" OR CMAKE_Fortran_COMPILER_ID STREQUAL "LLVMFlang")
+if (${F_COMPILER} STREQUAL "GFORTRAN")
   set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_GFORT")
-  if (NOT CMAKE_Fortran_COMPILER_ID STREQUAL "LLVMFlang")
-    # ensure reentrancy of lapack codes
-    set(FCOMMON_OPT "${FCOMMON_OPT} -Wall -frecursive")
-    # work around ABI violation in passing string arguments from C
-    set(FCOMMON_OPT "${FCOMMON_OPT} -fno-optimize-sibling-calls")
-    if (NOT NO_LAPACK)
-      # Don't include -lgfortran, when NO_LAPACK=1 or lsbcc
-      set(EXTRALIB "${EXTRALIB} -lgfortran")
-    endif ()
+  # ensure reentrancy of lapack codes
+  set(FCOMMON_OPT "${FCOMMON_OPT} -Wall -frecursive")
+  # work around ABI violation in passing string arguments from C
+  set(FCOMMON_OPT "${FCOMMON_OPT} -fno-optimize-sibling-calls")
+  #Don't include -lgfortran, when NO_LAPACK=1 or lsbcc
+  if (NOT NO_LAPACK)
+    set(EXTRALIB "{EXTRALIB} -lgfortran")
   endif ()
   if (NO_BINARY_MODE)
     if (MIPS64)
       if (BINARY64)
         set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=64")
-        if (INTERFACE64)
-          set(FCOMMON_OPT "${FCOMMON_OPT} -fdefault-integer-8")
-	endif ()
       else ()
         set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=n32")
       endif ()
     endif ()
     if (LOONGARCH64)
       if (BINARY64)
-        if (NOT CMAKE_Fortran_COMPILER_ID MATCHES "LLVMFlang.*")
-	  CHECK_C_COMPILER_FLAG("-mabi=lp64d" COMPILER_SUPPORT_LP64D_ABI)
-          if(COMPILER_SUPPORT_LP64D_ABI)
-	    set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=lp64d")
-	  else()
-	    set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=lp64")
-	  endif ()
-        endif ()
-        if (INTERFACE64) 
-          set(FCOMMON_OPT "${FCOMMON_OPT} -fdefault-integer-8") 
-        endif () 
+        set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=lp64")
       else ()
-        if (NOT CMAKE_Fortran_COMPILER_ID MATCHES "LLVMFlang.*")
-	  CHECK_C_COMPILER_FLAG("-mabi=ilp32d" COMPILER_SUPPORT_ILP32D_ABI)
-	  if(COMPILER_SUPPORT_ILP32D_ABI)
-	    set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=ilp32d")
-	  else()
-	    set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=lp32")
-          endif ()
-	endif ()
+        set(FCOMMON_OPT "${FCOMMON_OPT} -mabi=lp32")
       endif ()
     endif ()
-    if (RISCV64)
-      if (BINARY64)
-        if (INTERFACE64)
-          set(FCOMMON_OPT "${FCOMMON_OPT} -fdefault-integer-8")
-        endif ()
-      endif ()
-    endif ()
-    if (ARM64 AND INTERFACE64)
-          set(FCOMMON_OPT "${FCOMMON_OPT} -fdefault-integer-8")
-    endif ()
   else ()
     if (BINARY64)
-      if (NOT CMAKE_Fortran_COMPILER_ID MATCHES "LLVMFlang.*")
       set(FCOMMON_OPT "${FCOMMON_OPT} -m64")
-      endif ()
       if (INTERFACE64)
-        if (CMAKE_Fortran_COMPILER_ID STREQUAL "Intel")
-          if (WIN32)
-            set(FCOMMON_OPT "${FCOMMON_OPT} /integer-size:64")
-          else ()
-            set(FCOMMON_OPT "${FCOMMON_OPT} -integer-size 64")
-          endif ()
-        else ()
-          set(FCOMMON_OPT "${FCOMMON_OPT} -fdefault-integer-8")
-        endif ()
+        set(FCOMMON_OPT "${FCOMMON_OPT} -fdefault-integer-8")
       endif ()
     else ()
-        if (NOT CMAKE_Fortran_COMPILER_ID MATCHES "LLVMFlang.*")
-           set(FCOMMON_OPT "${FCOMMON_OPT} -m32")
-	endif ()
+      set(FCOMMON_OPT "${FCOMMON_OPT} -m32")
     endif ()
   endif ()
 
   if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-fopenmp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -fopenmp")
   endif ()
 endif ()
 
-if (${F_COMPILER} STREQUAL "INTEL" OR CMAKE_Fortran_COMPILER_ID MATCHES "Intel")
+if (${F_COMPILER} STREQUAL "INTEL")
   set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_INTEL")
   if (INTERFACE64)
     set(FCOMMON_OPT "${FCOMMON_OPT} -i8")
   endif ()
-  set(FCOMMON_OPT "${FCOMMON_OPT} -recursive -fp-model=consistent")
+  set(FCOMMON_OPT "${FCOMMON_OPT} -recursive")
   if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-qopenmp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -openmp")
   endif ()
 endif ()
 
 if (${F_COMPILER} STREQUAL "FUJITSU")
   set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_FUJITSU")
   if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-openmp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -openmp")
   endif ()
 endif ()
 
@@ -151,11 +109,11 @@ if (${F_COMPILER} STREQUAL "IBM")
     set(FCOMMON_OPT "${FCOMMON_OPT} -q32")
   endif ()
   if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-openmp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -openmp")
   endif ()
 endif ()
 
-if (${F_COMPILER} STREQUAL "PGI" OR ${F_COMPILER} STREQUAL "PGF95")
+if (${F_COMPILER} STREQUAL "PGI")
   set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_PGI")
   set(COMMON_PROF "${COMMON_PROF} -DPGICOMPILER")
   if (BINARY64)
@@ -168,7 +126,7 @@ if (${F_COMPILER} STREQUAL "PGI" OR ${F_COMPILER} STREQUAL "PGF95")
   endif ()
   set(FCOMMON_OPT "${FCOMMON_OPT} -Mrecursive")
   if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-mp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -mp")
   endif ()
 endif ()
 
@@ -195,7 +153,7 @@ if (${F_COMPILER} STREQUAL "PATHSCALE")
   endif ()
 
   if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-mp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -mp")
   endif ()
 endif ()
 
@@ -233,7 +191,7 @@ if (${F_COMPILER} STREQUAL "OPEN64")
 
   if (USE_OPENMP)
     set(FEXTRALIB "${FEXTRALIB} -lstdc++")
-    set(OpenMP_Fortran_FLAGS "-mp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -mp")
   endif ()
 endif ()
 
@@ -245,52 +203,14 @@ if (${F_COMPILER} STREQUAL "SUN")
     set(FCOMMON_OPT "${FCOMMON_OPT} -m64")
   endif ()
   if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-xopenmp=parallel" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -xopenmp=parallel")
   endif ()
 endif ()
 
 if (${F_COMPILER} STREQUAL "COMPAQ")
   set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_COMPAQ")
   if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-openmp" CACHE STRING "OpenMP Fortran compiler flags")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "CRAY")
-	set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_CRAYFC")
-  set(FCOMMON_OPT "${FCOMMON_OPT} -hnopattern")
-  if (INTERFACE64)
-    set (FCOMMON_OPT "${FCOMMON_OPT} -s integer64")
-  endif ()
-  if (NOT USE_OPENMP)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -fno-openmp")
-  else ()
-    set(OpenMP_Fortran_FLAGS "-fopenmp" CACHE STRING "OpenMP Fortran compiler flags")
-  endif ()
-endif ()
-
-if (${F_COMPILER} STREQUAL "NAGFOR")
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DF_INTERFACE_NAG")
-  if (INTERFACE64)
-    set(FCOMMON_OPT "${FCOMMON_OPT} -i8")
-  endif ()
-  # Options from Makefile.system
-  # -dcfuns: Enable non-standard double precision complex intrinsic functions
-  # -ieee=full: enables all IEEE arithmetic facilities including non-stop arithmetic.
-  # -w=obs: Suppress warning messages about obsolescent features
-  # -thread_safe: Compile code for safe execution in a multi-threaded environment.
-  # -recursive: Specifies that procedures are RECURSIVE by default.
-  set(FCOMMON_OPT "${FCOMMON_OPT} -dcfuns -recursive -ieee=full -w=obs -thread_safe")
-  # Options from Reference-LAPACK
-  # Suppress compiler banner and summary
-  set(FCOMMON_OPT "${FCOMMON_OPT} -quiet")
-  # Disable other common warnings
-  # -w=x77: Suppress warning messages about Fortran 77 features
-  # -w=ques: Suppress warning messages about questionable usage
-  # -w=unused: Suppress warning messages about unused variables
-  set(FCOMMON_OPT "${FCOMMON_OPT} -w=x77 -w=ques -w=unused")
-  if (USE_OPENMP)
-    set(OpenMP_Fortran_FLAGS "-openmp" CACHE STRING "OpenMP Fortran compiler flags")
+    set(FCOMMON_OPT "${FCOMMON_OPT} -openmp")
   endif ()
 endif ()
 

cmake/kernel.cmake

@@ -1,31 +1,3 @@
-###############################################################################
-# Copyright (c) 2025, The OpenBLAS Project
-# All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. 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.
-# 3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-###############################################################################
-
 # helper functions for the kernel CMakeLists.txt
 
 function(SetFallback KERNEL SOURCE_PATH)
@@ -107,10 +79,6 @@ macro(SetDefaultL1)
   SetFallback(CROTKERNEL zrot.S)
   SetFallback(ZROTKERNEL zrot.S)
   SetFallback(XROTKERNEL zrot.S)
-  SetFallback(SROTMKERNEL rotm.S)
-  SetFallback(DROTMKERNEL rotm.S)
-  SetFallback(QROTMKERNEL rotm.S)
-  SetFallback(BSCALKERNEL ../generic/scal.c)
   SetFallback(SSCALKERNEL scal.S)
   SetFallback(DSCALKERNEL scal.S)
   SetFallback(CSCALKERNEL zscal.S)
@@ -170,15 +138,9 @@ if (BUILD_BFLOAT16)
   SetFallback(SHSWAPKERNEL ../arm/swap.c)
   SetFallback(TOBF16KERNEL ../x86_64/tobf16.c)
   SetFallback(BF16TOKERNEL ../x86_64/bf16to.c)
-  SetFallback(BGEMVNKERNEL ../generic/gemv_n.c)
-  SetFallback(BGEMVTKERNEL ../generic/gemv_t.c)
   SetFallback(SBGEMVNKERNEL ../x86_64/sbgemv_n.c)
   SetFallback(SBGEMVTKERNEL ../x86_64/sbgemv_t.c)
 endif ()
-if (BUILD_HFLOAT16)
-  SetFallback(SHGEMVNKERNEL ../generic/gemv_n.c)
-  SetFallback(SHGEMVTKERNEL ../generic/gemv_t.c)
-endif ()
 endmacro ()
 
 macro(SetDefaultL2)
@@ -228,14 +190,8 @@ macro(SetDefaultL2)
   SetFallback(XHEMV_V_KERNEL ../generic/zhemv_k.c)
   SetFallback(XHEMV_M_KERNEL ../generic/zhemv_k.c)
 if (BUILD_BFLOAT16)
-  SetFallback(BGEMVNKERNEL ../generic/gemv_n.c)
-  SetFallback(BGEMVTKERNEL ../generic/gemv_t.c)
   SetFallback(SBGEMVNKERNEL ../x86_64/sbgemv_n.c)
   SetFallback(SBGEMVTKERNEL ../x86_64/sbgemv_t.c)
-endif ()
-if (BUILD_HFLOAT16)
-  SetFallback(SHGEMVNKERNEL ../generic/gemv_n.c)
-  SetFallback(SHGEMVTKERNEL ../generic/gemv_t.c)
   SetFallback(SHGERKERNEL ../generic/ger.c)
 endif ()
 endmacro ()
@@ -247,16 +203,6 @@ macro(SetDefaultL3)
   SetFallback(ZGEADD_KERNEL ../generic/zgeadd.c)
 if (BUILD_BFLOAT16)
   SetFallback(SHGEADD_KERNEL ../generic/geadd.c)
-  SetFallback(BGEMMKERNEL ../generic/gemmkernel_2x2.c)
-  SetFallback(BGEMM_BETA  ../generic/gemm_beta.c)
-  SetFallback(BGEMMINCOPY ../generic/gemm_ncopy_2.c)
-  SetFallback(BGEMMITCOPY ../generic/gemm_tcopy_2.c)
-  SetFallback(BGEMMONCOPY ../generic/gemm_ncopy_2.c)
-  SetFallback(BGEMMOTCOPY ../generic/gemm_tcopy_2.c)
-  SetFallback(BGEMMINCOPYOBJ bgemm_incopy.o)
-  SetFallback(BGEMMITCOPYOBJ bgemm_itcopy.o)
-  SetFallback(BGEMMONCOPYOBJ bgemm_oncopy.o)
-  SetFallback(BGEMMOTCOPYOBJ bgemm_otcopy.o)
   SetFallback(SBGEMMKERNEL ../generic/gemmkernel_2x2.c)
   SetFallback(SBGEMM_BETA  ../generic/gemm_beta.c)
   SetFallback(SBGEMMINCOPY ../generic/gemm_ncopy_2.c)
@@ -268,16 +214,5 @@ if (BUILD_BFLOAT16)
   SetFallback(SBGEMMONCOPYOBJ sbgemm_oncopy.o)
   SetFallback(SBGEMMOTCOPYOBJ sbgemm_otcopy.o)
 endif ()
-if (BUILD_HFLOAT16)
-  SetFallback(SHGEMMKERNEL ../generic/gemmkernel_2x2.c)
-  SetFallback(SHGEMM_BETA  ../generic/gemm_beta.c)
-  SetFallback(SHGEMMINCOPY ../generic/gemm_ncopy_2.c)
-  SetFallback(SHGEMMITCOPY ../generic/gemm_tcopy_2.c)
-  SetFallback(SHGEMMONCOPY ../generic/gemm_ncopy_2.c)
-  SetFallback(SHGEMMOTCOPY ../generic/gemm_tcopy_2.c)
-  SetFallback(SHGEMMINCOPYOBJ shgemm_incopy.o)
-  SetFallback(SHGEMMITCOPYOBJ shgemm_itcopy.o)
-  SetFallback(SHGEMMONCOPYOBJ shgemm_oncopy.o)
-  SetFallback(SHGEMMOTCOPYOBJ shgemm_otcopy.o)
-endif ()
+
 endmacro ()

cmake/lapacke.cmake

@@ -30,8 +30,6 @@ set(CSRC
   lapacke_cgebrd_work.c
   lapacke_cgecon.c
   lapacke_cgecon_work.c
-  lapacke_cgecxx.c
-  lapacke_cgecxx_work.c
   lapacke_cgeequ.c
   lapacke_cgeequ_work.c
   lapacke_cgeequb.c
@@ -72,6 +70,8 @@ set(CSRC
   lapacke_cgeqlf_work.c
   lapacke_cgeqp3.c
   lapacke_cgeqp3_work.c
+  lapacke_cgeqpf.c
+  lapacke_cgeqpf_work.c
   lapacke_cgeqr.c
   lapacke_cgeqr_work.c
   lapacke_cgeqr2.c
@@ -92,16 +92,10 @@ set(CSRC
   lapacke_cgerqf_work.c
   lapacke_cgesdd.c
   lapacke_cgesdd_work.c
-  lapacke_cgedmd.c
-  lapacke_cgedmd_work.c
-  lapacke_cgedmdq.c
-  lapacke_cgedmdq_work.c
   lapacke_cgesv.c
   lapacke_cgesv_work.c
   lapacke_cgesvd.c
   lapacke_cgesvd_work.c
-  lapacke_cgesvdq.c
-  lapacke_cgesvdq_work.c
   lapacke_cgesvdx.c
   lapacke_cgesvdx_work.c
   lapacke_cgesvj.c
@@ -150,8 +144,12 @@ set(CSRC
   lapacke_cggqrf_work.c
   lapacke_cggrqf.c
   lapacke_cggrqf_work.c
+  lapacke_cggsvd.c
+  lapacke_cggsvd_work.c
   lapacke_cggsvd3.c
   lapacke_cggsvd3_work.c
+  lapacke_cggsvp.c
+  lapacke_cggsvp_work.c
   lapacke_cggsvp3.c
   lapacke_cggsvp3_work.c
   lapacke_cgtcon.c
@@ -320,8 +318,6 @@ set(CSRC
   lapacke_clacn2.c
   lapacke_clag2z.c
   lapacke_clag2z_work.c
-  lapacke_clangb.c
-  lapacke_clangb_work.c
   lapacke_clange.c
   lapacke_clange_work.c
   lapacke_clanhe.c
@@ -566,8 +562,6 @@ set(CSRC
   lapacke_ctrsna_work.c
   lapacke_ctrsyl.c
   lapacke_ctrsyl_work.c
-  lapacke_ctrsyl3.c
-  lapacke_ctrsyl3_work.c
   lapacke_ctrtri.c
   lapacke_ctrtri_work.c
   lapacke_ctrtrs.c
@@ -600,8 +594,6 @@ set(CSRC
   lapacke_cungtr_work.c
   lapacke_cungtsqr_row.c
   lapacke_cungtsqr_row_work.c
-  lapacke_cunhr_col.c
-  lapacke_cunhr_col_work.c
   lapacke_cunmbr.c
   lapacke_cunmbr_work.c
   lapacke_cunmhr.c
@@ -661,8 +653,6 @@ set(DSRC
   lapacke_dgebrd_work.c
   lapacke_dgecon.c
   lapacke_dgecon_work.c
-  lapacke_dgecxx.c
-  lapacke_dgecxx_work.c
   lapacke_dgeequ.c
   lapacke_dgeequ_work.c
   lapacke_dgeequb.c
@@ -703,6 +693,8 @@ set(DSRC
   lapacke_dgeqlf_work.c
   lapacke_dgeqp3.c
   lapacke_dgeqp3_work.c
+  lapacke_dgeqpf.c
+  lapacke_dgeqpf_work.c
   lapacke_dgeqr.c
   lapacke_dgeqr_work.c
   lapacke_dgeqr2.c
@@ -723,10 +715,6 @@ set(DSRC
   lapacke_dgerqf_work.c
   lapacke_dgesdd.c
   lapacke_dgesdd_work.c
-  lapacke_dgedmd.c
-  lapacke_dgedmd_work.c
-  lapacke_dgedmdq.c
-  lapacke_dgedmdq_work.c
   lapacke_dgesv.c
   lapacke_dgesv_work.c
   lapacke_dgesvd.c
@@ -781,8 +769,12 @@ set(DSRC
   lapacke_dggqrf_work.c
   lapacke_dggrqf.c
   lapacke_dggrqf_work.c
+  lapacke_dggsvd.c
+  lapacke_dggsvd_work.c
   lapacke_dggsvd3.c
   lapacke_dggsvd3_work.c
+  lapacke_dggsvp.c
+  lapacke_dggsvp_work.c
   lapacke_dggsvp3.c
   lapacke_dggsvp3_work.c
   lapacke_dgtcon.c
@@ -811,8 +803,6 @@ set(DSRC
   lapacke_dlag2s_work.c
   lapacke_dlamch.c
   lapacke_dlamch_work.c
-  lapacke_dlangb.c
-  lapacke_dlangb_work.c
   lapacke_dlange.c
   lapacke_dlange_work.c
   lapacke_dlansy.c
@@ -880,8 +870,6 @@ set(DSRC
   lapacke_dorgtr_work.c
   lapacke_dorgtsqr_row.c
   lapacke_dorgtsqr_row_work.c
-  lapacke_dorhr_col.c
-  lapacke_dorhr_col_work.c
   lapacke_dormbr.c
   lapacke_dormbr_work.c
   lapacke_dormhr.c
@@ -1194,8 +1182,6 @@ set(DSRC
   lapacke_dtrsna_work.c
   lapacke_dtrsyl.c
   lapacke_dtrsyl_work.c
-  lapacke_dtrsyl3.c
-  lapacke_dtrsyl3_work.c
   lapacke_dtrtri.c
   lapacke_dtrtri_work.c
   lapacke_dtrtrs.c
@@ -1245,8 +1231,6 @@ set(SSRC
   lapacke_sgebrd_work.c
   lapacke_sgecon.c
   lapacke_sgecon_work.c
-  lapacke_sgecxx.c
-  lapacke_sgecxx_work.c
   lapacke_sgeequ.c
   lapacke_sgeequ_work.c
   lapacke_sgeequb.c
@@ -1287,6 +1271,8 @@ set(SSRC
   lapacke_sgeqlf_work.c
   lapacke_sgeqp3.c
   lapacke_sgeqp3_work.c
+  lapacke_sgeqpf.c
+  lapacke_sgeqpf_work.c
   lapacke_sgeqr.c
   lapacke_sgeqr_work.c
   lapacke_sgeqr2.c
@@ -1307,10 +1293,6 @@ set(SSRC
   lapacke_sgerqf_work.c
   lapacke_sgesdd.c
   lapacke_sgesdd_work.c
-  lapacke_sgedmd.c
-  lapacke_sgedmd_work.c
-  lapacke_sgedmdq.c
-  lapacke_sgedmdq_work.c
   lapacke_sgesv.c
   lapacke_sgesv_work.c
   lapacke_sgesvd.c
@@ -1365,8 +1347,12 @@ set(SSRC
   lapacke_sggqrf_work.c
   lapacke_sggrqf.c
   lapacke_sggrqf_work.c
+  lapacke_sggsvd.c
+  lapacke_sggsvd_work.c
   lapacke_sggsvd3.c
   lapacke_sggsvd3_work.c
+  lapacke_sggsvp.c
+  lapacke_sggsvp_work.c
   lapacke_sggsvp3.c
   lapacke_sggsvp3_work.c
   lapacke_sgtcon.c
@@ -1395,8 +1381,6 @@ set(SSRC
   lapacke_slag2d_work.c
   lapacke_slamch.c
   lapacke_slamch_work.c
-  lapacke_slangb.c
-  lapacke_slangb_work.c
   lapacke_slange.c
   lapacke_slange_work.c
   lapacke_slansy.c
@@ -1463,8 +1447,6 @@ set(SSRC
   lapacke_sorgtr_work.c
   lapacke_sorgtsqr_row.c
   lapacke_sorgtsqr_row_work.c
-  lapacke_sorhr_col.c
-  lapacke_sorhr_col_work.c
   lapacke_sormbr.c
   lapacke_sormbr_work.c
   lapacke_sormhr.c
@@ -1774,8 +1756,6 @@ set(SSRC
   lapacke_strsna_work.c
   lapacke_strsyl.c
   lapacke_strsyl_work.c
-  lapacke_strsyl3.c
-  lapacke_strsyl3_work.c
   lapacke_strtri.c
   lapacke_strtri_work.c
   lapacke_strtrs.c
@@ -1823,8 +1803,6 @@ set(ZSRC
   lapacke_zgebrd_work.c
   lapacke_zgecon.c
   lapacke_zgecon_work.c
-  lapacke_zgecxx.c
-  lapacke_zgecxx_work.c
   lapacke_zgeequ.c
   lapacke_zgeequ_work.c
   lapacke_zgeequb.c
@@ -1865,6 +1843,8 @@ set(ZSRC
   lapacke_zgeqlf_work.c
   lapacke_zgeqp3.c
   lapacke_zgeqp3_work.c
+  lapacke_zgeqpf.c
+  lapacke_zgeqpf_work.c
   lapacke_zgeqr.c
   lapacke_zgeqr_work.c
   lapacke_zgeqr2.c
@@ -1885,10 +1865,6 @@ set(ZSRC
   lapacke_zgerqf_work.c
   lapacke_zgesdd.c
   lapacke_zgesdd_work.c
-  lapacke_zgedmd.c
-  lapacke_zgedmd_work.c
-  lapacke_zgedmdq.c
-  lapacke_zgedmdq_work.c
   lapacke_zgesv.c
   lapacke_zgesv_work.c
   lapacke_zgesvd.c
@@ -1943,8 +1919,12 @@ set(ZSRC
   lapacke_zggqrf_work.c
   lapacke_zggrqf.c
   lapacke_zggrqf_work.c
+  lapacke_zggsvd.c
+  lapacke_zggsvd_work.c
   lapacke_zggsvd3.c
   lapacke_zggsvd3_work.c
+  lapacke_zggsvp.c
+  lapacke_zggsvp_work.c
   lapacke_zggsvp3.c
   lapacke_zggsvp3_work.c
   lapacke_zgtcon.c
@@ -2109,8 +2089,6 @@ set(ZSRC
   lapacke_zlacrm_work.c
   lapacke_zlag2c.c
   lapacke_zlag2c_work.c
-  lapacke_zlangb.c
-  lapacke_zlangb_work.c
   lapacke_zlange.c
   lapacke_zlange_work.c
   lapacke_zlanhe.c
@@ -2357,8 +2335,6 @@ set(ZSRC
   lapacke_ztrsna_work.c
   lapacke_ztrsyl.c
   lapacke_ztrsyl_work.c
-  lapacke_ztrsyl3.c
-  lapacke_ztrsyl3_work.c
   lapacke_ztrtri.c
   lapacke_ztrtri_work.c
   lapacke_ztrtrs.c
@@ -2391,8 +2367,6 @@ set(ZSRC
   lapacke_zungtr_work.c
   lapacke_zungtsqr_row.c
   lapacke_zungtsqr_row_work.c
-  lapacke_zunhr_col.c
-  lapacke_zunhr_col_work.c
   lapacke_zunmbr.c
   lapacke_zunmbr_work.c
   lapacke_zunmhr.c
@@ -2419,12 +2393,6 @@ set(ZSRC
   lapacke_csyr_work.c
   lapacke_ilaver.c
 )
-if (BUILD_LAPACK_DEPRECATED)
-	list(APPEND SSRC lapacke_sgeqpf.c lapacke_sgeqpf_work.c lapacke_sggsvd.c lapacke_sggsvd_work.c lapacke_sggsvp.c lapacke_sggsvp_work.c)
-	list(APPEND DSRC lapacke_dgeqpf.c lapacke_dgeqpf_work.c lapacke_dggsvd.c lapacke_dggsvd_work.c lapacke_dggsvp.c lapacke_dggsvp_work.c)
-	list(APPEND CSRC lapacke_cgeqpf.c lapacke_cgeqpf_work.c lapacke_cggsvd.c lapacke_cggsvd_work.c lapacke_cggsvp.c lapacke_cggsvp_work.c)
-	list(APPEND ZSRC lapacke_zgeqpf.c lapacke_zgeqpf_work.c lapacke_zggsvd.c lapacke_zggsvd_work.c lapacke_zggsvp.c lapacke_zggsvp_work.c)
-endif()
 
 set(SRCX
   lapacke_cgbrfsx.c       lapacke_cporfsx.c       lapacke_dgerfsx.c       lapacke_sgbrfsx.c       lapacke_ssyrfsx.c       lapacke_zherfsx.c
@@ -2513,8 +2481,6 @@ set(Utils_SRC
   lapacke_ctp_nancheck.c          lapacke_dtr_trans.c             lapacke_str_trans.c             lapacke_ztp_trans.c
   lapacke_ctp_trans.c             lapacke_lsame.c                 lapacke_xerbla.c                lapacke_ztr_nancheck.c
   lapacke_ctr_nancheck.c          lapacke_make_complex_double.c   lapacke_z_nancheck.c            lapacke_ztr_trans.c
-  lapacke_ctz_nancheck.c          lapacke_ctz_trans.c             lapacke_dtz_nancheck.c          lapacke_dtz_trans.c
-  lapacke_stz_nancheck.c          lapacke_stz_trans.c             lapacke_ztz_nancheck.c          lapacke_ztz_trans.c
 )
 
 set(LAPACKE_REL_SRC "")
@@ -2550,4 +2516,4 @@ endforeach ()
 
 set(lapacke_include_dir "${NETLIB_LAPACK_DIR}/LAPACKE/include")
 include_directories(${lapacke_include_dir})
-set_source_files_properties(${LAPACKE_SOURCES} PROPERTIES COMPILE_FLAGS "${LAPACK_CFLAGS} -fvisibility=default")
+set_source_files_properties(${LAPACKE_SOURCES} PROPERTIES COMPILE_FLAGS "${LAPACK_CFLAGS}")

cmake/openblas.pc.in

@@ -1,13 +1,11 @@
 libdir=@CMAKE_INSTALL_FULL_LIBDIR@
-libnameprefix=@LIBNAMEPREFIX@
-libnamesuffix=@LIBNAMESUFFIX@
 libsuffix=@SUFFIX64_UNDERSCORE@
 includedir=@CMAKE_INSTALL_FULL_INCLUDEDIR@
 
-openblas_config=USE_64BITINT=@INTERFACE64@ NO_CBLAS=@NO_CBLAS@ NO_LAPACK=@NO_LAPACK@ NO_LAPACKE=@NO_LAPACKE@ DYNAMIC_ARCH=@DYNAMIC_ARCH@ DYNAMIC_OLDER=@DYNAMIC_OLDER@ NO_AFFINITY=@NO_AFFINITY@ USE_OPENMP=@USE_OPENMP@ @CORE@ MAX_THREADS=@NUM_THREADS@ 
+openblas_config=USE_64BITINT=@USE_64BITINT@ NO_CBLAS=@NO_CBLAS@ NO_LAPACK=@NO_LAPACK@ NO_LAPACKE=@NO_LAPACKE@ DYNAMIC_ARCH=@DYNAMIC_ARCH@ DYNAMIC_OLDER=@DYNAMIC_OLDER@ NO_AFFINITY=@NO_AFFINITY@ USE_OPENMP=@USE_OPENMP@ @CORE@ MAX_THREADS=@NUM_THREADS@ 
 Name: OpenBLAS
 Description: OpenBLAS is an optimized BLAS library based on GotoBLAS2 1.13 BSD version
-Version: @OpenBLAS_VERSION@
-URL: https://github.com/OpenMathLib/OpenBLAS
-Libs: -L${libdir} -l${libnameprefix}openblas${libnamesuffix}${libsuffix} 
-Cflags: -I${includedir} @OpenMP_C_FLAGS@ 
+Version: @OPENBLAS_VERSION@
+URL: https://github.com/xianyi/OpenBLAS
+Libs: @OpenMP_C_FLAGS@ -L${libdir} -lopenblas${libsuffix} 
+Cflags: -I${includedir}

cmake/os.cmake

@@ -38,7 +38,7 @@ if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
 
     # Test for supporting MS_ABI
     # removed string parsing in favor of CMake's version comparison -hpa
-    set(GCC_VERSION ${CMAKE_C_COMPILER_VERSION})
+    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
     if (${GCC_VERSION} VERSION_GREATER 4.7 OR ${GCC_VERSION} VERSION_EQUAL 4.7)
       # GCC Version >=4.7
       # It is compatible with MSVC ABI.

cmake/system.cmake

@@ -1,30 +1,3 @@
-###############################################################################
-# Copyright (c) 2025, The OpenBLAS Project
-# All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. 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.
-# 3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-###############################################################################
 ##
 ## Author: Hank Anderson <hank@statease.com>
 ## Description: Ported from OpenBLAS/Makefile.system
@@ -48,15 +21,7 @@ endif()
 # Other files expect CORE, which is actually TARGET and will become TARGET_CORE for kernel build. Confused yet?
 # It seems we are meant to use TARGET as input and CORE internally as kernel.
 if(NOT DEFINED CORE AND DEFINED TARGET)
-  if (${TARGET} STREQUAL "LOONGSON3R5")
-    set(CORE "LA464")
-  elseif (${TARGET} STREQUAL "LOONGSON2K1000")
-    set(CORE "LA264")
-  elseif (${TARGET} STREQUAL "LOONGSONGENERIC")
-    set(CORE "LA64_GENERIC)")
-  else ()
-    set(CORE ${TARGET})
-  endif()
+  set(CORE ${TARGET})
 endif()
 
 # TARGET_CORE will override TARGET which is used in DYNAMIC_ARCH=1.
@@ -68,10 +33,10 @@ endif ()
 if (DEFINED BINARY AND DEFINED TARGET AND BINARY EQUAL 32)
   message(STATUS "Compiling a ${BINARY}-bit binary.")
   set(NO_AVX 1)
-  if (${TARGET} STREQUAL "HASWELL" OR ${TARGET} STREQUAL "ZEN" OR ${TARGET} STREQUAL "SANDYBRIDGE" OR ${TARGET} STREQUAL "SKYLAKEX" OR ${TARGET} STREQUAL "COOPERLAKE" OR ${TARGET} STREQUAL "SAPPHIRERAPIDS")
+  if (${TARGET} STREQUAL "HASWELL" OR ${TARGET} STREQUAL "SANDYBRIDGE" OR ${TARGET} STREQUAL "SKYLAKEX" OR ${TARGET} STREQUAL "COOPERLAKE" OR ${TARGET} STREQUAL "SAPPHIRERAPIDS")
     set(TARGET "NEHALEM")
   endif ()
-  if (${TARGET} STREQUAL "BULLDOZER" OR ${TARGET} STREQUAL "PILEDRIVER")
+  if (${TARGET} STREQUAL "BULLDOZER" OR ${TARGET} STREQUAL "PILEDRIVER" OR ${TARGET} STREQUAL "ZEN")
     set(TARGET "BARCELONA")
   endif ()
   if (${TARGET} STREQUAL "ARMV8" OR ${TARGET} STREQUAL "CORTEXA57" OR ${TARGET} STREQUAL "CORTEXA53" OR ${TARGET} STREQUAL "CORTEXA55")
@@ -90,7 +55,7 @@ if (DEFINED TARGET)
 endif ()
 
 # On x86_64 build getarch with march=native. This is required to detect AVX512 support in getarch.
-if (X86_64 AND NOT (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" OR ${CMAKE_C_COMPILER_ID} STREQUAL "NVHPC"))
+if (X86_64 AND NOT ${CMAKE_C_COMPILER_ID} STREQUAL "PGI")
   set(GETARCH_FLAGS "${GETARCH_FLAGS} -march=native")
 endif ()
 
@@ -147,9 +112,6 @@ if (POWER)
     set(HAVE_GAS 0)
   elseif (CMAKE_ASM_COMPILER_ID STREQUAL "Clang")
     set(CCOMMON_OPT "${CCOMMON_OPT} -fno-integrated-as")
-	if (${CMAKE_SYSTEM_NAME} STREQUAL "FreeBSD")
-      set(CCOMMON_OPT "${CCOMMON_OPT} -Wa,-mpwr10")
-    endif ()
     set(HAVE_GAS 0)
   endif ()
   set(GETARCH_FLAGS "${GETARCH_FLAGS} -DHAVE_GAS=${HAVE_GAS}")
@@ -198,16 +160,11 @@ else()
   endif ()
 endif ()
 
-if (C_LAPACK)
-  if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-    set(CCOMMON_OPT "${CCOMMON_OPT} -Wno-error=incompatible-pointer-types")
-  endif ()
-endif ()
-
 include("${PROJECT_SOURCE_DIR}/cmake/prebuild.cmake")
 if (DEFINED TARGET)
   if (${TARGET} STREQUAL COOPERLAKE AND NOT NO_AVX512)
     if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
+      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
         if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 10.09)
           set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=cooperlake")
         else()
@@ -215,14 +172,15 @@ if (DEFINED TARGET)
         endif()
     elseif (${CMAKE_C_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang")
          if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 8.99)
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=cooperlake -mllvm -exhaustive-register-search")
+          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=cooperlake")
         else()
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512 -mllvm -exhaustive-register-search")
+          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
         endif()
     endif()    
   endif()
   if (${TARGET} STREQUAL SAPPHIRERAPIDS AND NOT NO_AVX512)
     if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
+      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
         if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 11.0)
           set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=sapphirerapids")
         else()
@@ -230,43 +188,23 @@ if (DEFINED TARGET)
         endif()
     elseif (${CMAKE_C_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang")
          if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 12.0)
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=sapphirerapids -mllvm -exhaustive-register-search")
+          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=sapphirerapids")
         else()
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512 -mllvm -exhaustive-register-search")
+          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
         endif()
     endif()    
   endif()
   if (${TARGET} STREQUAL SKYLAKEX AND NOT NO_AVX512)
-    	  set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
-  	  if (${CMAKE_C_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang")
-	 	set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mllvm -exhaustive-register-search")
-  	  endif()
+    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
   endif()
-  
-  if (((${TARGET} STREQUAL ZEN) AND HAVE_AVX512VL) AND NOT NO_AVX512)
+  if (${TARGET} STREQUAL HASWELL AND NOT NO_AVX2)
     if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-        if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 12.99)
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=znver4")
-	else()
-    	  set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
-        endif()
-    elseif (${CMAKE_C_COMPILER_ID} STREQUAL "Clang" OR ${CMAKE_C_COMPILER_ID} STREQUAL "AppleClang")
-         if (${CMAKE_C_COMPILER_VERSION} VERSION_GREATER 15.99)
-          set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=znver4")
-	else()
-    	  set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=skylake-avx512")
-        endif()
-	set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mllvm -exhaustive-register-search")
-    endif()
-  endif()
-  
-  if ((${TARGET} STREQUAL HASWELL OR (${TARGET} STREQUAL ZEN AND NOT HAVE_AVX512VL)) AND NOT NO_AVX2)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "GNU")
-	    if (CMAKE_C_COMPILER_VERSION VERSION_GREATER 4.7 OR CMAKE_C_COMPILER_VERSION VERSION_EQUAL 4.7)
+      execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+      if (${GCC_VERSION} VERSION_GREATER 4.7 OR ${GCC_VERSION} VERSION_EQUAL 4.7)
         set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2")
       endif()
     elseif (${CMAKE_C_COMPILER_ID} STREQUAL "CLANG")
-      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2 -mfma")
+      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -mavx2")
     endif()
   endif()
   if (DEFINED HAVE_AVX)
@@ -301,124 +239,26 @@ if (DEFINED TARGET)
   endif()
 
   if (${TARGET} STREQUAL POWER10)
-    if (CMAKE_C_COMPILER_VERSION VERSION_GREATER 10.2 OR CMAKE_C_COMPILER_VERSION VERSION_EQUAL 10.2)
+    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+    if (${GCC_VERSION} VERSION_GREATER 10.2 OR ${GCC_VERSION} VERSION_EQUAL 10.2)
       set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mcpu=power10 -mtune=power10 -mvsx -fno-fast-math")
     else ()
-	    message(FATAL_ERROR "Compiler GCC ${CMAKE_C_COMPILER_VERSION} does not support Power10.")
+      message(FATAL_ERROR "Compiler GCC.${GCC_VERSION} does not support Power10.")
     endif()
   endif()
   if (${TARGET} STREQUAL POWER9)
-    if (CMAKE_C_COMPILER_VERSION VERSION_GREATER 5.0 OR CMAKE_C_COMPILER_VERSION VERSION_EQUAL 5.0)
+    execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpversion OUTPUT_VARIABLE GCC_VERSION)
+    if (${GCC_VERSION} VERSION_GREATER 5.0 OR ${GCC_VERSION} VERSION_EQUAL 5.0)
       set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mcpu=power9 -mtune=power9 -mvsx -fno-fast-math")
     else ()
       set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math")
-      message(WARNING "Compiler GCC ${CMAKE_C_COMPILER_VERSION} does not support fully Power9.")
+      message(WARNING "Compiler GCC.${GCC_VERSION} does not support fully Power9.")
     endif()
   endif()
   if (${TARGET} STREQUAL POWER8)
     set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mcpu=power8 -mtune=power8 -mvsx -fno-fast-math")
   endif()
-
-if (${TARGET} STREQUAL Z13)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=z13 -mzvector")
 endif()
-if (${TARGET} STREQUAL Z14)
-    set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=z14 -mzvector")
-endif()
-
-if (${TARGET} STREQUAL NEOVERSEV1)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
-	set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -Msve_intrinsics -march=armv8.4-a+sve+bf16 -mtune=neoverse-v1")
-    else ()
-    if (CMAKE_C_COMPILER_VERSION VERSION_GREATER 10.4 OR CMAKE_C_COMPILER_VERSION VERSION_EQUAL 10.4)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv8.4-a+sve+bf16 -mtune=neoverse-v1")
-    else ()
-	    message(FATAL_ERROR "Compiler ${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_VERSION} does not support Neoverse V1.")
-    endif()
-    endif()
-  endif()
-  if (${TARGET} STREQUAL NEOVERSEN2)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
-	set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -Msve-intrinsics -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-n2")
-    else ()
-    if (CMAKE_C_COMPILER_VERSION VERSION_GREATER 10.4 OR CMAKE_C_COMPILER_VERSION VERSION_EQUAL 10.4)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv8.5-a+sve+sve2+bf16 -mtune=neoverse-n2")
-    else ()
-	    message(FATAL_ERROR "Compiler $${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_VERSION} does not support Neoverse N2.")
-    endif()
-    endif()
-  endif()
-  if (${TARGET} STREQUAL NEOVERSEV2)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
-	    set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -Msve-intrinsics -march=armv9-a+sve+sve2+bf16 -mtune=neoverse-v2")
-    else ()
-    if (CMAKE_C_COMPILER_VERSION VERSION_GREATER 13.0 OR CMAKE_C_COMPILER_VERSION VERSION_EQUAL 13.0)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mcpu=neoverse-v2")
-    elseif (CMAKE_C_COMPILER_VERSION VERSION_GREATER 10.4 OR CMAKE_C_COMPILER_VERSION VERSION_EQUAL 10.4)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv8.4-a+sve+bf16 -mtune=neoverse-v1")
-    else ()
-	    message(FATAL_ERROR "Compiler $${CMAKE_C_COMPILER} ${CMAKE_C_COMPILER_VERSION} does not support Neoverse V2.")
-    endif()
-    endif()
-  endif()
-  if (${TARGET} STREQUAL ARMV8SVE)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -Msve-intrinsics -march=armv8.2-a+sve")
-    else ()
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv8.2-a+sve")
-    endif()
-  endif()
-  if (${TARGET} STREQUAL ARMV9SME)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv9-a+sme+sme-f64f64 -O3")
-	  if (${CMAKE_SYSTEM_NAME} STREQUAL Windows AND ${CMAKE_C_COMPILER_ID} MATCHES "Clang")
-	  set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mllvm --aarch64-stack-hazard-size=0")
-	  endif()
-  endif()
-  if (${TARGET} STREQUAL VORTEXM4)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv8.4-a+sme+sme-f64f64 -O3")
-	  if (${CMAKE_SYSTEM_NAME} STREQUAL Windows AND ${CMAKE_C_COMPILER_ID} MATCHES "Clang")
-	  set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -mllvm --aarch64-stack-hazard-size=0")
-	  endif()
-  endif()
-  if (${TARGET} STREQUAL A64FX)
-    if (${CMAKE_C_COMPILER_ID} STREQUAL "PGI" AND NOT NO_SVE)
-      set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -Msve-intrinsics -march=armv8.2-a+sve -mtune=a64fx")
-    else ()
-	  if (CMAKE_C_COMPILER_VERSION VERSION_GREATER 10.4 OR CMAKE_C_COMPILER_VERSION VERSION_EQUAL 10.4)
-        set (KERNEL_DEFINITIONS  "${KERNEL_DEFINITIONS} -march=armv8.2-a+sve -mtune=a64fx")
-      else ()
-        message(FATAL_ERROR "Compiler $${CMAKE_C_COMPILER} {GCC_VERSION} does not support A64FX.")
-      endif()
-    endif()
-  endif()
-
-  if ((${TARGET} STREQUAL RISCV64_ZVL128B) OR (${TARGET} STREQUAL RISCV64_ZVL256B))
-    set (RISCV64_OPT "rv64imafdcv")
-    if (BUILD_BFLOAT16)
-      set (RISCV64_OPT "${RISCV64_OPT}_zvfbfwma")
-    endif()
-    if (BUILD_HFLOAT16)
-      set (RISCV64_OPT "${RISCV64_OPT}_zvfh_zfh")
-    endif()
-    if (${TARGET} STREQUAL RISCV64_ZVL256B)
-      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=${RISCV64_OPT}_zvl256b -mabi=lp64d")
-    endif()
-    if (${TARGET} STREQUAL RISCV64_ZVL128B)
-      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=${RISCV64_OPT}_zvl128b -mabi=lp64d")
-    endif()
-  endif()
-  if (${TARGET} STREQUAL RISCV64_GENERIC)
-      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=rv64imafdc -mabi=lp64d")
-    endif()
-    if (${TARGET} STREQUAL U74)
-      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=rv64imafdc_zba_zbb -mabi=lp64d -mtune=sifive-u74")
-    endif()
-    if (${TARGET} STREQUAL x280)
-      set (KERNEL_DEFINITIONS "${KERNEL_DEFINITIONS} -march=rv64imafdcv_zba_zbb_zfh_zvl512b -mabi=lp64d")
-    endif()
-
-endif()
-
 if (DEFINED BINARY)
   message(STATUS "Compiling a ${BINARY}-bit binary.")
 endif ()
@@ -444,35 +284,8 @@ if (NOT NOFORTRAN)
   # Fortran Compiler dependent settings
   include("${PROJECT_SOURCE_DIR}/cmake/fc.cmake")
 else ()
-  if (NOT XXXX)
-    set(C_LAPACK 1)
-    if (INTERFACE64)
-      set (CCOMMON_OPT "${CCOMMON_OPT} -DLAPACK_ILP64")
-    endif ()
-    set(TIMER "NONE")
-  else ()
-    set (NO_LAPACK 1)
-  endif ()
-endif ()
-
-if (USE_OPENMP)
-  find_package(OpenMP COMPONENTS C REQUIRED)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DUSE_OPENMP")
-  if (NOT NOFORTRAN)
-    find_package(OpenMP COMPONENTS Fortran REQUIRED)
-    # Avoid mixed OpenMP linkage
-    get_target_property(OMP_C_LIBS OpenMP::OpenMP_C INTERFACE_LINK_LIBRARIES)
-    get_target_property(OMP_F_LIBS OpenMP::OpenMP_Fortran INTERFACE_LINK_LIBRARIES)
-    if (NOT OMP_C_LIBS STREQUAL OMP_F_LIBS)
-      message(NOTICE
-        "CMake detected different OpenMP libraries for C and Fortran:\n"
-        "C=${OMP_C_LIBS}\n"
-        "Fortran=${OMP_F_LIBS}\n"
-        "In case you encounter issues, please check that this is correct.\n"
-        "You may pass -DOpenMP_<lang>_LIB_NAMES and -DOpenMP_<libname>_LIBRARY to cmake to manually force the OpenMP library."
-      )
-    endif()
-  endif ()
+set(NO_LAPACK 1)
+set(NO_LAPACKE 1)
 endif ()
 
 if (BINARY64)
@@ -496,45 +309,21 @@ if (NEED_PIC)
   if (NOT NOFORTRAN)
     if (${F_COMPILER} STREQUAL "SUN")
       set(FCOMMON_OPT "${FCOMMON_OPT} -pic")
-    elseif (${F_COMPILER} STREQUAL "NAGFOR")
-      set(FCOMMON_OPT "${FCOMMON_OPT} -PIC")
     else ()
       set(FCOMMON_OPT "${FCOMMON_OPT} -fPIC")
     endif ()
   endif()
 endif ()
 
-if (X86_64 OR ${CORE} STREQUAL POWER10 OR ARM64 OR LOONGARCH64)
+if (X86_64 OR ${CORE} STREQUAL POWER10)
   set(SMALL_MATRIX_OPT TRUE)
 endif ()
-if (ARM64)
-  set(GEMM_GEMV_FORWARD TRUE)
-  set(SBGEMM_GEMV_FORWARD TRUE)
-  set(BGEMM_GEMV_FORWARD TRUE)
-endif ()
-if (POWER)
-  set(GEMM_GEMV_FORWARD TRUE)
-  set(SBGEMM_GEMV_FORWARD TRUE)
-endif ()
-if (RISCV64)
-  set(GEMM_GEMV_FORWARD TRUE)
-endif ()
-
-if (GEMM_GEMV_FORWARD)
-  set(CCOMMON_OPT "${CCOMMON_OPT} -DGEMM_GEMV_FORWARD")
-endif ()
-if (SBGEMM_GEMV_FORWARD)
-    set(CCOMMON_OPT "${CCOMMON_OPT} -DSBGEMM_GEMV_FORWARD")
-endif ()
-if (BGEMM_GEMV_FORWARD)
-    set(CCOMMON_OPT "${CCOMMON_OPT} -DBGEMM_GEMV_FORWARD")
-endif ()
 if (SMALL_MATRIX_OPT)
   set(CCOMMON_OPT "${CCOMMON_OPT} -DSMALL_MATRIX_OPT")
 endif ()
 
 if (DYNAMIC_ARCH)
-  if (X86 OR X86_64 OR ARM64 OR POWER OR RISCV64 OR LOONGARCH64 OR ZARCH)
+  if (X86 OR X86_64 OR ARM64 OR POWER)
     set(CCOMMON_OPT "${CCOMMON_OPT} -DDYNAMIC_ARCH")
     if (DYNAMIC_OLDER)
       set(CCOMMON_OPT "${CCOMMON_OPT} -DDYNAMIC_OLDER")
@@ -649,11 +438,10 @@ set(CCOMMON_OPT "${CCOMMON_OPT} -DBLAS3_MEM_ALLOC_THRESHOLD=${BLAS3_MEM_ALLOC_TH
 endif()
 endif()
 endif()
-  
-set(LIBPREFIX "lib${LIBNAMEPREFIX}openblas")
-
-if (DEFINED LIBNAMESUFFIX AND NOT "${LIBNAMESUFFIX}" STREQUAL "")
-  set(LIBPREFIX "lib${LIBNAMEPREFIX}openblas${LIBNAMESUFFIX}")
+if (DEFINED LIBNAMESUFFIX)
+  set(LIBPREFIX "libopenblas_${LIBNAMESUFFIX}")
+else ()
+  set(LIBPREFIX "libopenblas")
 endif ()
 
 if (NOT DEFINED SYMBOLPREFIX)
@@ -741,51 +529,27 @@ endif()
 if (BUILD_BFLOAT16)
        set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBUILD_BFLOAT16")
 endif()
-if (BUILD_HFLOAT16)
-       set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -DBUILD_HFLOAT16")
-endif()
 if(NOT MSVC)
 set(CMAKE_ASM_FLAGS "${CMAKE_ASM_FLAGS} ${CCOMMON_OPT}")
-set(CMAKE_C_FLAGS "${CMAKE_C_FLAGS} -fvisibility=hidden")
 endif()
 # TODO: not sure what PFLAGS is -hpa
 set(PFLAGS "${PFLAGS} ${CCOMMON_OPT} -I${TOPDIR} -DPROFILE ${COMMON_PROF}")
-if ("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
-
-  if ("${F_COMPILER}" STREQUAL "FLANG")
-    if (${CMAKE_Fortran_COMPILER_VERSION} VERSION_LESS_EQUAL 3)
-      set(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE} -fno-unroll-loops")
-    endif ()
-  endif ()
-    if (ARM64 AND CMAKE_Fortran_COMPILER_ID MATCHES "LLVMFlang.*" AND CMAKE_SYSTEM_NAME STREQUAL "Windows")
-      set(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE} -O2")
-    endif ()
-endif ()
-
 
 set(CMAKE_Fortran_FLAGS "${CMAKE_Fortran_FLAGS} ${FCOMMON_OPT}")
 # TODO: not sure what FPFLAGS is -hpa
 set(FPFLAGS "${FPFLAGS} ${FCOMMON_OPT} ${COMMON_PROF}")
 
 #For LAPACK Fortran codes.
-set(LAPACK_FFLAGS "${LAPACK_FFLAGS} ${CMAKE_Fortran_FLAGS}" )
-if (LAPACK_STRLEN)
-	set (LAPACK_FFLAGS "${LAPACK_FFLAGS} -DLAPACK_STRLEN=${LAPACK_STRLEN}")
-endif()
+set(LAPACK_FFLAGS "${LAPACK_FFLAGS} ${CMAKE_Fortran_FLAGS}")
 set(LAPACK_FPFLAGS "${LAPACK_FPFLAGS} ${FPFLAGS}")
 
-if (CMAKE_Fortran_COMPILER)
-  if ("${F_COMPILER}" STREQUAL "NAGFOR" OR "${F_COMPILER}" STREQUAL "CRAY" OR CMAKE_Fortran_COMPILER_ID MATCHES "LLVMFlang.*")
-    set(FILTER_FLAGS "-msse3;-mssse3;-msse4.1;-mavx;-mavx2,-mskylake-avx512")
-    if (CMAKE_Fortran_COMPILER_ID MATCHES "LLVMFlang.*")
-      message(STATUS "removing fortran flags not supported by the compiler")
-      set(FILTER_FLAGS "${FILTER_FLAGS};-m32;-m64")
-    endif ()
-    foreach (FILTER_FLAG ${FILTER_FLAGS})
-      string(REPLACE ${FILTER_FLAG} "" LAPACK_FFLAGS ${LAPACK_FFLAGS})
-      string(REPLACE ${FILTER_FLAG} "" LAPACK_FPFLAGS ${LAPACK_FPFLAGS})
-    endforeach ()
-  endif ()
+#Disable -fopenmp for LAPACK Fortran codes on Windows.
+if (${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
+  set(FILTER_FLAGS "-fopenmp;-mp;-openmp;-xopenmp=parallel")
+  foreach (FILTER_FLAG ${FILTER_FLAGS})
+    string(REPLACE ${FILTER_FLAG} "" LAPACK_FFLAGS ${LAPACK_FFLAGS})
+    string(REPLACE ${FILTER_FLAG} "" LAPACK_FPFLAGS ${LAPACK_FPFLAGS})
+  endforeach ()
 endif ()
 
 if ("${F_COMPILER}" STREQUAL "GFORTRAN")
@@ -805,11 +569,14 @@ endif ()
 if (${CMAKE_C_COMPILER} STREQUAL "LSB" OR ${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
   set(LAPACK_CFLAGS "${LAPACK_CFLAGS} -DLAPACK_COMPLEX_STRUCTURE")
 endif ()
-if (${CMAKE_C_COMPILER_ID} MATCHES "IntelLLVM" AND ${CMAKE_SYSTEM_NAME} STREQUAL "Windows")
-	set(LAPACK_CFLAGS "${LAPACK_CFLAGS} -DNOCHANGE")
-endif ()
 
-string(REPLACE "-fvisibility=hidden" "" LAPACK_CFLAGS ${LAPACK_CFLAGS})
+if ("${CMAKE_BUILD_TYPE}" STREQUAL "Release")
+if ("${F_COMPILER}" STREQUAL "FLANG")
+if (${CMAKE_Fortran_COMPILER_VERSION} VERSION_LESS_EQUAL 3)
+  set(CMAKE_Fortran_FLAGS_RELEASE "${CMAKE_Fortran_FLAGS_RELEASE} -fno-unroll-loops")
+endif ()
+endif ()
+endif ()
 
 if (NOT DEFINED SUFFIX)
   set(SUFFIX o)
@@ -841,10 +608,6 @@ else ()
   endif ()
 endif ()
 
-if (DEFINED FIXED_LIBNAME)
-  set (LIBNAME "${LIBPREFIX}.${LIBSUFFIX}")
-  set (LIBNAME "${LIBPREFIX}_p.${LIBSUFFIX}")
-endif()
 
 set(LIBDLLNAME "${LIBPREFIX}.dll")
 set(LIBSONAME "${LIBNAME}.${LIBSUFFIX}.so")
@@ -885,10 +648,6 @@ if (DEFINED ARCH)
     set(USE_GEMM3M 1)
   endif ()
 
-  if (EMSCRIPTEN)
-    set(USE_GEMM3M 0)
-  endif ()
-
   if (${CORE} STREQUAL "generic")
     set(USE_GEMM3M 0)
   endif ()

cmake/system_check.cmake

@@ -10,10 +10,6 @@ if (${HOST_OS} STREQUAL "WINDOWS")
   set(HOST_OS WINNT)
 endif ()
 
-if (${HOST_OS} STREQUAL "IOS")
-  set(HOST_OS DARWIN)
-endif ()
-
 if (${HOST_OS} STREQUAL "LINUX")
 # check if we're building natively on Android (TERMUX)
     EXECUTE_PROCESS( COMMAND uname -o COMMAND tr -d '\n' OUTPUT_VARIABLE OPERATING_SYSTEM)
@@ -28,34 +24,23 @@ if(MINGW)
     execute_process(COMMAND ${CMAKE_C_COMPILER} -dumpmachine
               OUTPUT_VARIABLE OPENBLAS_MINGW_TARGET_MACHINE
               OUTPUT_STRIP_TRAILING_WHITESPACE)
-    if(OPENBLAS_MINGW_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64|aarch64")
+    if(OPENBLAS_MINGW_TARGET_MACHINE MATCHES "amd64|x86_64|AMD64")
       set(MINGW64 1)
     endif()
 endif()
 
 # Pretty thorough determination of arch. Add more if needed
 if(CMAKE_CL_64 OR MINGW64)
-  if (CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*|arm64.*|ARM64.*)")
-    set(ARM64 1)
-  else()
-    set(X86_64 1)
-  endif()
-elseif(OS_EMSCRIPTEN)
-    set(WASM 1)
+  set(X86_64 1)
 elseif(MINGW OR (MSVC AND NOT CMAKE_CROSSCOMPILING))
   set(X86 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc.*|power.*|Power.*" OR (CMAKE_SYSTEM_NAME MATCHES "Darwin" AND CMAKE_OSX_ARCHITECTURES MATCHES "ppc.*"))
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "ppc.*|power.*|Power.*")
   set(POWER 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "mips64.*")
   set(MIPS64 1)
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "loongarch64.*")
   set(LOONGARCH64 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "riscv64.*")
-  set(RISCV64 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "s390.*")
-  set(ZARCH 1)
-  set(BINARY 64)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*" OR (CMAKE_SYSTEM_NAME MATCHES "Darwin" AND CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*"))
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*")
   if (NOT BINARY)
     if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
       set(X86_64 1)
@@ -71,7 +56,7 @@ elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "amd64.*|x86_64.*|AMD64.*" OR (CMAKE_SYSTE
   endif()
 elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "i686.*|i386.*|x86.*|amd64.*|AMD64.*")
   set(X86 1)
-elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*|arm64.*|ARM64.*|armv8.*)")
+elseif(CMAKE_SYSTEM_PROCESSOR MATCHES "^(aarch64.*|AARCH64.*|arm64.*|ARM64.*)")
   if("${CMAKE_SIZEOF_VOID_P}" EQUAL "8")
     set(ARM64 1)
   else()
@@ -105,8 +90,6 @@ elseif(X86)
   set(ARCH "x86")
 elseif(POWER)
   set(ARCH "power")
-elseif(ZARCH)
-  set(ARCH "zarch")
 elseif(MIPS32)
   set(ARCH "mips")
 elseif(MIPS64)
@@ -115,14 +98,12 @@ elseif(ARM)
   set(ARCH "arm")
 elseif(ARM64)
   set(ARCH "arm64")
-elseif(LOONGARCH64)
-  set(ARCH "loongarch64")
 else()
   set(ARCH ${CMAKE_SYSTEM_PROCESSOR} CACHE STRING "Target Architecture")
 endif ()
 
 if (NOT BINARY)
-  if (X86_64 OR ARM64 OR MIPS64 OR LOONGARCH64 OR RISCV64 OR (POWER AND NOT (CMAKE_OSX_ARCHITECTURES STREQUAL "ppc")))
+  if (X86_64 OR ARM64 OR POWER OR MIPS64 OR LOONGARCH64)
     set(BINARY 64)
   else ()
     set(BINARY 32)
@@ -146,26 +127,6 @@ endif()
 endif()
 endif()
 
-if (ARM64)
-if (NOT NO_SVE)
-  file(WRITE ${PROJECT_BINARY_DIR}/sve.c "#include <arm_sve.h>\n\n int main(void){}\n")
-  execute_process(COMMAND ${CMAKE_C_COMPILER} -march=armv8-a+sve -c -o ${PROJECT_BINARY_DIR}/sve.o ${PROJECT_BINARY_DIR}/sve.c OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE NO_SVE)
-if (NO_SVE EQUAL 1)
-set (CCOMMON_OPT "${CCOMMON_OPT} -DNO_SVE")
-endif()
-  file(REMOVE "${PROJECT_BINARY_DIR}/sve.c" "${PROJECT_BINARY_DIR}/sve.o")
-endif()
-
-if (NOT NO_SME)
-  file(WRITE ${PROJECT_BINARY_DIR}/sme.S ".text \n.global sme_test\n\nsme_test:\nsmstart\nsmstop\nret\n")
-  execute_process(COMMAND ${CMAKE_C_COMPILER} -march=armv9-a+sve2+sme -c -v -o ${PROJECT_BINARY_DIR}/sme.o ${PROJECT_BINARY_DIR}/sme.S OUTPUT_QUIET ERROR_QUIET RESULT_VARIABLE NO_SME)
-if (NO_SME EQUAL 1)
-set (CCOMMON_OPT "${CCOMMON_OPT} -DNO_SME")
-endif()
-  file(REMOVE "${PROJECT_BINARY_DIR}/sme.S" "${PROJECT_BINARY_DIR}/sme.o")
-endif()
-endif()
-
 include(CheckIncludeFile)
 CHECK_INCLUDE_FILE("stdatomic.h" HAVE_C11)
 if (HAVE_C11 EQUAL 1)

cmake/utils.cmake

@@ -1,31 +1,3 @@
-###############################################################################
-# Copyright (c) 2025, The OpenBLAS Project
-# All rights reserved.
-# Redistribution and use in source and binary forms, with or without
-# modification, are permitted provided that the following conditions are
-# met:
-# 1. Redistributions of source code must retain the above copyright
-#    notice, this list of conditions and the following disclaimer.
-# 2. 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.
-# 3. Neither the name of the OpenBLAS project 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 WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE
-# ARE DISCLAIMED. IN NO EVENT SHALL THE OPENBLAS PROJECT 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.
-###############################################################################
-
 # Functions to help with the OpenBLAS build
 
 # Reads string from getarch into CMake vars. Format of getarch vars is VARNAME=VALUE
@@ -44,14 +16,6 @@ endfunction ()
 macro(ParseMakefileVars MAKEFILE_IN)
   message(STATUS "Reading vars from ${MAKEFILE_IN}...")
   set (C_COMPILER ${CMAKE_C_COMPILER_ID})
-  set (OSNAME ${CMAKE_SYSTEM_NAME})
-  if (${C_COMPILER} MATCHES Clang)
-    set (C_COMPILER CLANG)
-  endif ()
-  if (${OSNAME} STREQUAL Windows)
-    set (OSNAME WINNT)
-  endif ()
-  #message(STATUS OS ${OSNAME} COMPILER ${C_COMPILER})
   set (IfElse 0)
   set (ElseSeen 0)
   set (SkipIfs 0)
@@ -123,15 +87,6 @@ macro(ParseMakefileVars MAKEFILE_IN)
       #message(STATUS "skipping ${makefile_line}")
       continue ()
     endif ()
-
-    # Example 1: SBGEMM_SMALL_M_PERMIT =
-    # Unset the variable
-    string(REGEX MATCH "([0-9_a-zA-Z]+)[ \t]*=[ \t]*$" line_match "${makefile_line}")
-    if (NOT "${line_match}" STREQUAL "")
-      set(var_name ${CMAKE_MATCH_1})
-      unset(${var_name})
-    endif()
-
     string(REGEX MATCH "([0-9_a-zA-Z]+)[ \t]*=[ \t]*(.+)$" line_match "${makefile_line}")
     if (NOT "${line_match}" STREQUAL "")
       #message(STATUS "match on ${line_match}")
@@ -223,8 +178,8 @@ macro(ParseMakefileVars MAKEFILE_IN)
         set (HasValidGroup 1)
         set (STR ${CMAKE_MATCH_4})
       endif ()
-      if (DEFINED CMAKE_MATCH_1 AND ${HasValidGroup} EQUAL 1)
-        if (NOT (CMAKE_MATCH_1 STREQUAL ${STR}))
+      if (DEFINED ${CMAKE_MATCH_1} AND ${HasValidGroup} EQUAL 1)
+        if (NOT (${${CMAKE_MATCH_1}} STREQUAL ${STR}))
           #message (STATUS "condition is true")
           set (IfElse 1)
           continue ()
@@ -375,12 +330,9 @@ function(GenerateNamedObjects sources_in)
       if (NOT no_float_type)
         string(SUBSTRING ${float_type} 0 1 float_char)
         string(TOLOWER ${float_char} float_char)
-        if (${float_type} STREQUAL "BFLOAT16" AND NOT "${defines_in}" MATCHES "BGEM")
-          set (float_char "sb")
-        endif ()
-        if (${float_type} STREQUAL "HFLOAT16" AND NOT "${defines_in}" MATCHES "HGEM")
-          set (float_char "sh")
-        endif ()
+	if (${float_type} STREQUAL "BFLOAT16")
+		set (float_char "sb")
+	endif ()
       endif ()
 
       if (NOT name_in)
@@ -430,9 +382,6 @@ function(GenerateNamedObjects sources_in)
       endif ()
       if (${float_type} STREQUAL "BFLOAT16")
         list(APPEND obj_defines "BFLOAT16")
-      endif ()
-	  if (${float_type} STREQUAL "HFLOAT16")
-        list(APPEND obj_defines "HFLOAT16")
       endif ()
       if (${float_type} STREQUAL "COMPLEX" OR ${float_type} STREQUAL "ZCOMPLEX")
         list(APPEND obj_defines "COMPLEX")

common.h

@@ -1,6 +1,5 @@
 /*********************************************************************/
 /* Copyright 2009, 2010 The University of Texas at Austin.           */
-/* Copyright 2025 The OpenBLAS Project.                              */
 /* All rights reserved.                                              */
 /*                                                                   */
 /* Redistribution and use in source and binary forms, with or        */
@@ -57,7 +56,6 @@ extern "C" {
 #define __USE_SVID
 #endif
 
-#include "exports.h"
 #ifdef BUILD_KERNEL
 #include "config_kernel.h"
 #else
@@ -80,22 +78,6 @@ extern "C" {
 #endif
 #endif
 
-#ifndef ASSEMBLER
-#if defined(HAVE_C11) && !defined(__cplusplus)
-#if defined(C_GCC) && ( __GNUC__ < 7)
-// workaround for GCC bug 65467
-#ifndef _Atomic
-#define _Atomic volatile
-#endif
-#endif
-#include <stdatomic.h>
-#else
-#ifndef _Atomic
-#define _Atomic volatile
-#endif
-#endif
-#endif
-
 #if !defined(NOINCLUDE) && !defined(ASSEMBLER)
 #include <stdio.h>
 #include <stdlib.h>
@@ -108,7 +90,7 @@ extern "C" {
 #endif
 #include <time.h>
 
-#if defined(OS_LINUX) || defined(OS_QNX)
+#ifdef OS_LINUX
 #include <malloc.h>
 #include <sched.h>
 #endif
@@ -125,7 +107,7 @@ extern "C" {
 #endif
 #endif
 
-#if defined(OS_HAIKU) || defined(OS_QNX)
+#ifdef OS_HAIKU
 #define NO_SYSV_IPC
 #endif
 
@@ -210,10 +192,8 @@ extern "C" {
 
 #ifdef NEEDBUNDERSCORE
 #define BLASFUNC(FUNC) FUNC##_
-#define OPENBLAS_API(FUNC) OPENBLAS_EXPORT FUNC##_
 #else
 #define BLASFUNC(FUNC) FUNC
-#define OPENBLAS_API(FUNC) OPENBLAS_EXPORT FUNC
 #endif
 
 #undef	USE_PTHREAD_LOCK
@@ -286,14 +266,6 @@ typedef uint16_t bfloat16;
 #define BFLOAT16CONVERSION 1
 #endif
 
-#ifdef BUILD_HFLOAT16
-  #ifndef hfloat16
-  typedef _Float16 hfloat16;
-  #endif
-#else
-  typedef uint16_t hfloat16;
-#endif
-
 #ifdef USE64BITINT
 typedef BLASLONG blasint;
 #if defined(OS_WINDOWS) && defined(__64BIT__)
@@ -337,19 +309,8 @@ typedef int blasint;
 #elif defined(BFLOAT16)
 #define IFLOAT	bfloat16
 #define XFLOAT IFLOAT
-#ifdef BGEMM
-#define FLOAT	bfloat16
-#else
-#define FLOAT float
-#endif
-#define SIZE   2
-#define BASE_SHIFT 1
-#define ZBASE_SHIFT 2
-#elif defined(HFLOAT16)
-#define IFLOAT	hfloat16
-#define XFLOAT	IFLOAT
 #define FLOAT	float
-#define SIZE	2
+#define SIZE   2
 #define BASE_SHIFT 1
 #define ZBASE_SHIFT 2
 #else
@@ -381,10 +342,28 @@ typedef int blasint;
 #define MAX_CPU_NUMBER 2
 #endif
 
+#if defined(OS_SUNOS)
+#define YIELDING	thr_yield()
+#endif
+
+#if defined(OS_WINDOWS)
+#if defined(_MSC_VER) && !defined(__clang__)
+#define YIELDING    YieldProcessor()
+#else
+#define YIELDING	SwitchToThread()
+#endif
+#endif
+
 #if defined(ARMV7) || defined(ARMV6) || defined(ARMV8) || defined(ARMV5)
 #define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop; \n");
 #endif
 
+#ifdef BULLDOZER
+#ifndef YIELDING
+#define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop;\n");
+#endif
+#endif
+
 
 #if defined(POWER8) || defined(POWER9) || defined(POWER10)
 #ifndef YIELDING
@@ -392,44 +371,28 @@ typedef int blasint;
 #endif
 #endif
 
-
-#if defined(ARCH_X86_64)
+/*
+#ifdef PILEDRIVER
 #ifndef YIELDING
 #define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop;\n");
 #endif
 #endif
+*/
 
-#if defined(ARCH_RISCV64)
+/*
+#ifdef STEAMROLLER
 #ifndef YIELDING
 #define YIELDING        __asm__ __volatile__ ("nop;nop;nop;nop;nop;nop;nop;nop;\n");
 #endif
 #endif
-
-#if defined(ARCH_WASM)
-#ifndef YIELDING
-#define YIELDING
-#endif
-#endif
-
-#if defined(_MSC_VER) && !defined(__clang__)
-#undef YIELDING // MSVC doesn't support assembly code
-#define YIELDING    	YieldProcessor()
-#endif
+*/
 
 #ifndef YIELDING
-#if defined(OS_SUNOS)
-#define YIELDING	thr_yield()
-
-#elif defined(OS_WINDOWS)
-#define YIELDING	SwitchToThread()
-
-#else // assume POSIX.1-2008
 #define YIELDING	sched_yield()
 #endif
-#endif
 
 /***
-To alloc job_t on heap or stack.
+To alloc job_t on heap or statck.
 please https://github.com/xianyi/OpenBLAS/issues/246
 ***/
 #if defined(OS_WINDOWS)
@@ -449,12 +412,6 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #include "common_quad.h"
 #endif
 
-#ifndef ASSEMBLER
-#if defined(HAVE_C11) && !defined(__cplusplus)
-#define BLAS_LOCK_DEFINED
-#endif
-#endif
-
 #ifdef ARCH_ALPHA
 #include "common_alpha.h"
 #endif
@@ -517,18 +474,6 @@ please https://github.com/xianyi/OpenBLAS/issues/246
 #include "common_loongarch64.h"
 #endif
 
-#ifdef ARCH_E2K
-#include "common_e2k.h"
-#endif
-
-#ifdef ARCH_CSKY
-#include "common_csky.h"
-#endif
-
-#ifdef ARCH_WASM
-#include "common_wasm.h"
-#endif
-
 #ifndef ASSEMBLER
 #ifdef OS_WINDOWSSTORE
 typedef char env_var_t[MAX_PATH];
@@ -572,7 +517,7 @@ static inline unsigned long long rpcc(void){
 #endif // !RPCC_DEFINED
 
 #if !defined(BLAS_LOCK_DEFINED) && defined(__GNUC__)
-static __inline void blas_lock(volatile BLASULONG *address){
+static void __inline blas_lock(volatile BLASULONG *address){
 
   do {
     while (*address) {YIELDING;};
@@ -582,27 +527,6 @@ static __inline void blas_lock(volatile BLASULONG *address){
 #define BLAS_LOCK_DEFINED
 #endif
 
-#if defined(HAVE_C11) && !defined(__cplusplus)
-static __inline void blas_lock(volatile BLASULONG *address) {
-  BLASULONG expected = 0;
-  while (!atomic_compare_exchange_strong((volatile _Atomic BLASULONG *)address,
-             &expected, (BLASULONG)1)) {
-    expected = 0;
-    YIELDING;
-  }
-}
-#endif
-
-static __inline void blas_unlock(volatile BLASULONG *address){
-#if defined(HAVE_C11) && !defined(__cplusplus)
-  atomic_store((volatile _Atomic BLASULONG *)address, (BLASULONG)0);
-#else
-  MB;
-  *address = 0;
-#endif
-}
-
-
 #ifndef RPCC_DEFINED
 #error "rpcc() implementation is missing for your platform"
 #endif
@@ -764,18 +688,7 @@ int get_num_proc   (int);
 int get_node_equal (void);
 #endif
 
-OPENBLAS_EXPORT void goto_set_num_threads(int);
-
-/* Cooperative cancellation of in-flight operations
- * (implemented in driver/others/openblas_cancel.c).  These symbols are
- * exported without SYMBOLPREFIX/SYMBOLSUFFIX decoration. */
-size_t *openblas_cancel_token(void);
-OPENBLAS_EXPORT void openblas_cancel(size_t *token, size_t loaded_token);
-
-/* Internal helpers for the instrumented compute drivers. */
-size_t  openblas_cancel_begin(void);
-size_t *openblas_cancel_self(void);
-int     openblas_cancel_poll(size_t *slot, size_t gen);
+void goto_set_num_threads(int);
 
 void gotoblas_affinity_init(void);
 void gotoblas_affinity_quit(void);
@@ -785,7 +698,6 @@ void gotoblas_profile_init(void);
 void gotoblas_profile_quit(void);
 	
 int support_avx512(void);	
-int support_sme1(void);	
 
 #ifdef USE_OPENMP
 
@@ -797,6 +709,19 @@ __declspec(dllimport) int __cdecl omp_in_parallel(void);
 __declspec(dllimport) int __cdecl omp_get_num_procs(void);
 #endif
 
+#ifdef HAVE_C11
+#if defined(C_GCC) && ( __GNUC__ < 7) 
+// workaround for GCC bug 65467
+#ifndef _Atomic
+#define _Atomic volatile
+#endif
+#endif
+#include <stdatomic.h>
+#else
+#ifndef _Atomic
+#define _Atomic volatile
+#endif
+#endif
 
 #else
 #ifdef __ELF__
@@ -805,13 +730,17 @@ int omp_get_num_procs(void) __attribute__ ((weak));
 #endif
 #endif
 
+static __inline void blas_unlock(volatile BLASULONG *address){
+  MB;
+  *address = 0;
+}
 
 #ifdef OS_WINDOWSSTORE
 static __inline int readenv_atoi(char *env) {
 	return 0;
 }
 #else
-#if defined(OS_WINDOWS) && !defined(OS_CYGWIN_NT)
+#ifdef OS_WINDOWS
 static __inline int readenv_atoi(char *env) {
   env_var_t p;
   return readenv(p,env) ? 0 : atoi(p);
@@ -827,7 +756,7 @@ static __inline int readenv_atoi(char *env) {
 #endif
 #endif
 
-#if !defined(BFLOAT16) && (!defined(XDOUBLE) || !defined(QUAD_PRECISION))
+#if !defined(XDOUBLE) || !defined(QUAD_PRECISION)
 
 static __inline void compinv(FLOAT *b, FLOAT ar, FLOAT ai){
 
@@ -894,26 +823,6 @@ typedef struct {
 #endif
 
 #include "common_interface.h"
-
-/* Internal declaration of the public C XERBLA callback API. Keep this out of
- * common_interface.h, whose contents are copied verbatim into f77blas.h and
- * are not adjusted for SYMBOLPREFIX/SYMBOLSUFFIX by the CMake build. */
-#ifndef ASSEMBLER
-#ifdef __cplusplus
-extern "C" {
-#endif
-#ifndef OPENBLAS_XERBLA_HANDLER_DEFINED
-#define OPENBLAS_XERBLA_HANDLER_DEFINED
-typedef void (*openblas_xerbla_handler)(const char *name,
-                                        const blasint *info,
-                                        size_t name_length);
-#endif
-OPENBLAS_EXPORT openblas_xerbla_handler openblas_set_xerbla(openblas_xerbla_handler handler);
-#ifdef __cplusplus
-}
-#endif
-#endif
-
 #ifdef SANITY_CHECK
 #include "common_reference.h"
 #endif

common_alpha.h

@@ -43,10 +43,9 @@
 
 #define MB  asm("mb")
 #define WMB asm("wmb")
-#define RMB asm("mb")
+#define RMB asm("rmb")
 
-#ifndef BLAS_LOCK_DEFINED
-static __inline void blas_lock(unsigned long *address){
+static void __inline blas_lock(unsigned long *address){
 #ifndef __DECC
   unsigned long tmp1, tmp2;
   asm volatile(
@@ -79,7 +78,6 @@ static __inline void blas_lock(unsigned long *address){
 #endif
 }
 #define BLAS_LOCK_DEFINED
-#endif
 
 static __inline unsigned int rpcc(void){
 
@@ -145,16 +143,6 @@ static __inline int blas_quickdivide(unsigned int x, unsigned int y){
 	.ent REALNAME; \
 REALNAME:
 
-#define PROLOGUE_EXPORT \
-	.arch ev6; \
-	.set noat; \
-	.set noreorder; \
-.text; \
-	.align 5; \
-	.globl REALNAME; \
-	.ent REALNAME; \
-REALNAME:
-
 #ifdef PROFILE
 #define PROFCODE \
 	ldgp	$gp, 0($27); \