add cross compilation

Author: zawata

.github/workflows/release.yaml

@@ -24,31 +24,30 @@ jobs:
       - name: Install pnpm
         uses: pnpm/action-setup@v4
 
-      # linux
-      - name: Install Rust
-        if: ${{ matrix.os == 'ubuntu-latest' }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: stable
-          targets: ${{ matrix.arch == 'arm64' && 'aarch64-unknown-linux-gnu' || 'x86_64-unknown-linux-gnu' }}
+      - name: Install Linux Dependencies
+        if: runner.os == 'Linux'
+        run: |
+          sudo apt-get update
+          sudo apt-get install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu
 
-      # macos
-      - name: Install Rust
-        if: ${{ matrix.os == 'macos-latest' }}
-        uses: dtolnay/rust-toolchain@master
-        with:
-          toolchain: stable
-          targets: ${{ matrix.arch == 'arm64' && 'aarch64-apple-darwin' || 'x86_64-apple-darwin' }}
+      - name: Get Target Name
+        id: get_target
+        env:
+          npm_config_arch: ${{ matrix.arch }}
+        shell: bash
+        run: |
+          TARGET_NAME=$(node ./utils/getTarget.js)
+          echo "target_name=$TARGET_NAME" >> $GITHUB_OUTPUT
 
-      # windows
       - name: Install Rust
-        if: ${{ matrix.os == 'windows-latest' }}
         uses: dtolnay/rust-toolchain@master
         with:
           toolchain: stable
-          targets: ${{ matrix.arch == 'arm64' && 'aarch64-pc-windows-msvc' || 'x86_64-pc-windows-msvc' }}
+          targets: ${{ steps.get_target.outputs.target_name }}
 
       - name: Building
+        env:
+          npm_config_arch: ${{ matrix.arch }}
         run: pnpm install
 
       - name: Uploading

build.js

@@ -4,25 +4,27 @@ const { promises: fs, constants } = require('fs');
 const { promisify } = require('util');
 const execFile = promisify(require('child_process').execFile);
 
-const { spawn, paths, exists } = require('./shared');
+const { getRustTarget } = require('./utils/getTarget');
+const { spawn, buildPaths, exists } = require('./shared');
 
 (async () => {
-  if (await exists(paths.exeFinal)) {
+  if (await exists(buildPaths.exeFinal)) {
     return;
   }
 
-  if (!(await exists(paths.bin))) {
-    await fs.mkdir(paths.bin, { recursive: true });
+  if (!(await exists(buildPaths.bin))) {
+    await fs.mkdir(buildPaths.bin, { recursive: true });
   }
 
   await spawn('cargo', [
     'build',
-    `--manifest-path=${path.join(paths.submodule, 'Cargo.toml')}`,
-    `--target-dir=${paths.build}`,
+    `--target=${getRustTarget()}`,
+    `--manifest-path=${path.join(buildPaths.submodule, 'Cargo.toml')}`,
+    `--target-dir=${buildPaths.build}`,
     '--release'
   ]);
   await fs.copyFile(
-    paths.exeOut,
-    paths.exeFinal
+    buildPaths.exeOut,
+    buildPaths.exeFinal
   );
 })();

index.js

@@ -1,14 +1,14 @@
-const { exists, paths, spawn } = require('./shared')
+const { exists, runtimePaths, spawn } = require('./shared')
 const { promisify } = require('util');
 
 const dumpSymbolSync = function (binaryPath, callback) {
-  exists(paths.exeFinal)
+  exists(runtimePaths.exeFinal)
   .then(binExists => {
     if (!binExists) {
       throw new Error('Unable to find "dump_syms"');
     }
 
-    return spawn(paths.exeFinal, [binaryPath]);
+    return spawn(runtimePaths.exeFinal, [binaryPath]);
   })
   .then(b => callback(null, b))
   .catch(e => callback(e, null))

shared.js

@@ -2,6 +2,8 @@ const path = require('path');
 const { promises: fs } = require('fs');
 const { spawn: spawnSync } = require('child_process');
 
+const { getTargetArch } = require('./utils/getTarget');
+
 const spawn = (...args) => new Promise((resolve, reject) => {
   let stdout = Buffer.alloc(0);
   let stderr = Buffer.alloc(0);
@@ -27,12 +29,13 @@ const exists = async (filePath) => fs.access(filePath).then(() => true).catch(e
 module.exports.exists = exists;
 
 const exe = process.platform === 'win32' ? '.exe' : '';
-const paths = {
+const getPaths = (arch) => ({
   submodule: path.join(__dirname, 'deps', 'dump_syms'),
-  bin: path.join(__dirname, 'bin', `${process.platform}-${process.arch}`),
+  bin: path.join(__dirname, 'bin', `${process.platform}-${arch}`),
   build: path.join(__dirname, 'build'),
   exeOut: path.join(__dirname, 'build', 'release', `dump_syms${exe}`),
-  exeFinal: path.join(__dirname, 'bin', `${process.platform}-${process.arch}`, `dump_syms${exe}`),
-};
+  exeFinal: path.join(__dirname, 'bin', `${process.platform}-${arch}`, `dump_syms${exe}`),
+});
 
-module.exports.paths = paths;
+module.exports.runtimePaths = getPaths(process.arch);
+module.exports.buildPaths = getPaths(getTargetArch());

utils/getTarget.js

@@ -0,0 +1,28 @@
+const getTargetArch = () => {
+  return process.env.npm_config_arch || process.arch;
+}
+
+module.exports.getTargetArch = getTargetArch;
+
+const getRustTarget = (platform = process.platform, arch = getTargetArch()) => {
+  let target = '';
+
+  if (platform === 'linux') {
+    target += arch === 'arm64' ? 'aarch64-unknown-linux-gnu' : 'x86_64-unknown-linux-gnu';
+  } else if (platform === 'darwin') {
+    target += arch === 'arm64' ? 'aarch64-apple-darwin' : 'x86_64-apple-darwin';
+  } else if (platform === 'win32') {
+    target += arch === 'arm64' ? 'aarch64-pc-windows-msvc' : 'x86_64-pc-windows-msvc';
+  } else {
+    throw new Error(`Unsupported platform: ${platform}`);
+  }
+
+  return target;
+};
+
+module.exports.getRustTarget = getRustTarget;
+
+if (require.main === module) {
+  const target = getRustTarget();
+  console.log(target);
+}