add nasm support for msvc

.github/workflows/main.yml

@@ -76,6 +76,10 @@ jobs:
           rust: stable-x86_64-msvc
           os: windows-latest
           crt_static: yes
+        - target: x86_64-pc-windows-msvc
+          rust: stable-x86_64-msvc
+          os: windows-latest
+          nasm_exe: installed
 
     steps:
     - uses: actions/checkout@v1
@@ -90,18 +94,26 @@ jobs:
     - name: Use strawberry perl
       if: startsWith(matrix.os, 'windows')
       run: echo OPENSSL_SRC_PERL=C:/Strawberry/perl/bin/perl >> $GITHUB_ENV
-    - run: |
+    - name: Run tests (not Windows)
+      if: "!startsWith(matrix.os, 'windows')"
+      run: |
         set -e
         cargo generate-lockfile
         ./ci/run-docker.sh ${{ matrix.target }}
-      if: "!startsWith(matrix.os, 'windows')"
-      name: Run tests (not Windows)
-    - run: |
+    - name: Download nasm.exe (Windows)
+      if: matrix.nasm_exe == 'installed'
+      run: |
+        WINNASMVERSION='2.15.05'
+        curl -O https://www.nasm.us/pub/nasm/releasebuilds/${WINNASMVERSION}/win64/nasm-${WINNASMVERSION}-win64.zip
+        unzip nasm-${WINNASMVERSION}-win64.zip
+        echo "$GITHUB_WORKSPACE\\nasm-${WINNASMVERSION}" >> $GITHUB_PATH
+        echo "OPENSSL_RUST_USE_NASM=1" >> $GITHUB_ENV
+    - name: Run tests (Windows)
+      if: startsWith(matrix.os, 'windows')
+      run: |
         cargo test --manifest-path testcrate/Cargo.toml --target ${{ matrix.target }} -vv
         cargo test --manifest-path testcrate/Cargo.toml --target ${{ matrix.target }} --release -vv
         cargo run --release --target ${{ matrix.target }} --manifest-path testcrate/Cargo.toml --features package -vv
-      if: startsWith(matrix.os, 'windows')
-      name: Run tests (Windows)
 
   rustfmt:
     name: Rustfmt

README.md

@@ -15,6 +15,22 @@ This project is licensed under either of
 
 at your option.
 
+### Windows MSVC Assembly
+Building OpenSSL for `windows-msvc` targets, users can choose whether to enable
+assembly language routines, which requires [nasm](https://www.nasm.us/).  
+The build process will automatically detect whether `nasm.exe` is installed in
+PATH. If found, the assembly language routines will be enabled (in other words,
+the `no-asm` option will NOT be configured).  
+You can manipulate this behavior by setting the `OPENSSL_RUST_USE_NASM` environment
+variable:
+* `1`: Force enable the assembly language routines. (panic if `nasm.exe` is not
+availible.)
+* `0`: Force disable the assembly language routines even if the `nasm.exe` can be
+found in PATH.
+* not set: Let the build process automatically detect whether `nasm.exe` is
+installed. If found, enable. If not, disable.
+However, this environment variable does not take effects on non-windows platforms.
+
 ### Contribution
 
 Unless you explicitly state otherwise, any contribution intentionally submitted

src/lib.rs

@@ -65,6 +65,53 @@ impl Build {
         }
     }
 
+    #[cfg(windows)]
+    fn check_env_var(&self, var_name: &str) -> Option<bool> {
+        env::var_os(var_name).map(|s| {
+            if s == "1" {
+                // a message to stdout, let user know asm is force enabled
+                println!(
+                    "{}: nasm.exe is force enabled by the \
+                    'OPENSSL_RUST_USE_NASM' env var.",
+                    env!("CARGO_PKG_NAME")
+                );
+                true
+            } else if s == "0" {
+                // a message to stdout, let user know asm is force disabled
+                println!(
+                    "{}: nasm.exe is force disabled by the \
+                    'OPENSSL_RUST_USE_NASM' env var.",
+                    env!("CARGO_PKG_NAME")
+                );
+                false
+            } else {
+                panic!(
+                    "The environment variable {} is set to an unacceptable value: {:?}",
+                    var_name, s
+                );
+            }
+        })
+    }
+
+    #[cfg(windows)]
+    fn is_nasm_ready(&self) -> bool {
+        self.check_env_var("OPENSSL_RUST_USE_NASM")
+            .unwrap_or_else(|| {
+                // On Windows, use cmd `where` command to check if nasm is installed
+                let wherenasm = Command::new("cmd")
+                    .args(&["/C", "where nasm"])
+                    .output()
+                    .expect("Failed to execute `cmd`.");
+                wherenasm.status.success()
+            })
+    }
+
+    #[cfg(not(windows))]
+    fn is_nasm_ready(&self) -> bool {
+        // We assume that nobody would run nasm.exe on a non-windows system.
+        false
+    }
+
     pub fn build(&mut self) -> Artifacts {
         let target = &self.target.as_ref().expect("TARGET dir not set")[..];
         let host = &self.host.as_ref().expect("HOST dir not set")[..];
@@ -147,9 +194,18 @@ impl Build {
         }
 
         if target.contains("msvc") {
-            // On MSVC we need nasm.exe to compile the assembly files, but let's
-            // just pessimistically assume for now that's not available.
-            configure.arg("no-asm");
+            // On MSVC we need nasm.exe to compile the assembly files.
+            // ASM compiling will be enabled if nasm.exe is installed, unless
+            // the environment variable `OPENSSL_RUST_USE_NASM` is set.
+            if self.is_nasm_ready() {
+                // a message to stdout, let user know asm is enabled
+                println!(
+                    "{}: Enable the assembly language routines in building OpenSSL.",
+                    env!("CARGO_PKG_NAME")
+                );
+            } else {
+                configure.arg("no-asm");
+            }
         }
 
         let os = match target {