wos-porter

Plugin wos-porter from marketplace extension-wos-porter in qualcomm/extension-wos-porter. Commands read from the repo's manifest — 1 month ago.

Skills (11)

• arm64-baseline-porting

  Fallback skill for porting x64 code to ARM64 when no specific spec matches. Provides mandatory architectural constraints that ALL ARM64 migrations must respect regardless of code pattern — covering both hand-written assembly and C/intrinsics output. Use when the dispatcher receives a porting_item wi

• arm64-inlineasm-to-intrinsics

  Convert ARM64 NEON inline assembly written in Clang/GCC-style `asm volatile(...)` blocks into maintainable C/C++ intrinsics, and must build a Verification project that compares the original asm against the translated intrinsics for semantic equivalence. Use when: (1) the user provides a source file

• asm-x64-to-arm64

  Convert x64 assembly to AArch64 arm64 — both inline asm (asm volatile / __asm__) and standalone MASM .asm files (PROC/ENDP, equ, macro/endm) translated to GAS .S form. Use when porting x64-specific asm to arm64, adding arm64 support alongside an existing x64 path, translating an entire MASM hot-loop

• intrinsics-x64-to-arm64

  Expert guidance for porting x86/x64 SSE/AVX vectorized C++ to ARM64 NEON, grounded in the Microsoft STL's two real backends (vector_algorithms.cpp). Use this skill when: translating __m128i/__m256i intrinsics to NEON (uint8x16_t/uint16x8_t/etc.), replacing _mm_*/_mm256_* with vld1q/vst1q/vceqq/vmaxv

• jit-arm64ec-virtualalloc-fix-skill

  Analyze ARM64EC JIT executable memory allocation bugs where JIT-generated ARM64 or ARM64EC code is allocated with VirtualAlloc/VirtualAllocEx and then misclassified or treated as X64 code. Use this skill whenever the user mentions ARM64EC, JIT code pages, VirtualAlloc vs VirtualAlloc2, MEM_EXTENDED_

• sse-avx-to-neon

  Port x86 SSE/AVX intrinsics to ARM NEON, including CRC32 PCLMULQDQ → PMULL. Use when translating x86/x64 intrinsic code to NEON equivalents, adding ARM paths alongside existing x86 code, writing ARM NEON compute kernels from SSE/AVX specifications, or porting PCLMULQDQ-based CRC32 to PMULL. Triggers

• wos-build-error-recipes

  ARM64 build/link error diagnosis and fix recipes for Windows (C-series compiler errors, LNK linker errors, D80xx conflicts, .sln/.vcxproj platform mis-configuration, dumpbin AA64 validation). Load when triaging an ARM64 build log line-by-line — do NOT load for general porting questions.

• wos-forbidden-skip-reasons

  Canonical list of forbidden vs valid skip reasons for ARM64 SIMD porting, plus the PowerShell regex audit block used by wos-porter Phase 8 gate G7c and wos-optimizer Hard Constraints. Load when auditing an optimizer report, when the optimizer decides whether to skip a Tier-S file, or when writing th

• wos-neon-reference

  SSE/AVX → ARM NEON translation reference for Windows ARM64. Load when actively converting x86 SIMD intrinsics to NEON, choosing between baseline ARMv8.0 and optional ARMv8.2+ extensions, or checking the Windows ARM64 baseline ISA (AES/SHA1/SHA2/PMULL/CRC32) — no runtime feature check needed for

• wos-toolchain-discovery

  Canonical PowerShell block that detects the Windows ARM64 build toolchain (host arch, Visual Studio path, ARM64-target cl.exe, MSBuild, dumpbin, vcvars script) and caches the result to .copilot/state/wos-toolchain.json for reuse across agents/phases. Load when any wos-* agent needs to build/validate

• wos-woa-dashboard

  Windows on Arm Ecosystem Dashboard lookup — resolves each project dependency to a native-ARM64 / building / unsupported / unknown status per Arm AppReady, with citation links. Load during wos-analyzer Phase 2 (dependency audit) and when writing the Phase 8 Arm AppReady Status section. Also emits t

Slash commands (3)

• /wos-porter:wos-etl-hotspot

  Analyze an ETL scenario trace for a built application: detect CPU-hottest functions, cross-reference with source, apply Windows ARM64 optimizations (NEON/SVE/SVE2/SME, scalar tuning, branch/memory improvements), delegate build and test to sub-agents, and write an HTML report.

• /wos-porter:wos-porter

  Port an open-source x64 application to Windows ARM64 (clone, analyze, port build+source, build, test, NEON-optimize, verify, report). Runs the wos-porter pipeline in the main loop.

• /wos-porter:x64-benchmarker

  Clone (or reuse) a project, build for x64, run all tests and benchmarks, auto-generate benchmarks if none exist, and produce a final report with build status, test results, and performance metrics stored under x64_benchmark/.

Subagents (10)

• wos-analyzer

  Read-only scan of a repo for Windows ARM64 readiness: build systems, SIMD/asm usage, arch guards, x64-only dependencies, CI config.

• wos-benchmark-optimizer

  Differential Windows x64 → ARM64 performance optimizer. Invoked ONLY when a Windows x64 benchmark result file is supplied alongside the repo. Compares the x64 baseline against the Windows ARM64 benchmark, identifies functions that are slow on ARM64 relative to x64, and optimizes exactly those with h

• wos-build-porter

  Port build systems (CMake, MSBuild, Meson, Cargo, Make, Bazel, GN, Gradle, node-gyp, .NET, etc.) to add Windows ARM64 targets. Loads per-build-system recipe instructions on demand.

• wos-builder

  Build a project for Windows ARM64 and validate binaries with dumpbin. Iteratively fixes ARM64 compile/link errors. Consumes wos-toolchain-discovery skill.

• wos-code-porter

  Add ARM64 arch guards and scalar/NEON fallbacks to x64 source (SSE/AVX intrinsics, inline asm, x86 compiler intrinsics). Deep NEON kernel work is deferred to wos-optimizer.

• wos-etl-hotspot

  Analyze an ETL scenario trace for a built application: run hotspot_analysis.py with the .exe, .pdb, .etl, and source directory to detect top CPU-hottest functions and cross-reference them against source code, identify in-depth (transitive) dependent callees, then directly apply the full range of Win

• wos-optimizer

  Apply hand-written ARM NEON / ACLE intrinsics to a ported Windows ARM64 project for performance. Use after the ARM64 build succeeds and tests pass. Hand-ports SSE/AVX translation units (*_sse*.cpp, *_avx*.cpp, *_simd.cpp). No sse2neon/simde shims. Per-kernel benchmark-gated.

• wos-porter

  Port an open-source x64 application to Windows ARM64. Use when: porting a GitHub repo to ARM64, adding ARM64 build/source support, converting x64 SIMD to NEON, or generating an ARM64 porting patch.

• wos-tester

  Run tests and benchmarks on already-built Windows ARM64 binaries and fix ARM64-specific failures (illegal-instruction, alignment, weak memory ordering, x86-only assertions, DLL loads).

• x64-benchmarker

  Clone (or reuse) a project, build it for x64, run all tests and benchmarks, auto-generate benchmarks if none exist, and produce a final report with build status, test results, and performance metrics stored under x64_benchmark/. Use when: benchmarking a GitHub repo on x64, validating x64 build+test

Similar plugins