Reusing Legacy Code in WebAssembly: Key Challenges of Cross-Compilation and Code Semantics Preservation (2412.20258v1)

Abstract: WebAssembly (Wasm) has emerged as a powerful technology for executing high-performance code and reusing legacy code in web browsers. With its increasing adoption, ensuring the reliability of WebAssembly code becomes paramount. In this paper, we investigate how well WebAssembly compilers fulfill code reusability. Specifically, we inquire (1) what challenges arise when cross-compiling a high-level language codebase into WebAssembly and (2) how faithfully WebAssembly compilers preserve code semantics in this new binary. Through a study on 115 open-source codebases, we identify the key challenges in cross-compiling legacy C/C++ code into WebAssembly, highlighting the risks of silent miscompilation and compile-time errors. We categorize these challenges based on their root causes and propose corresponding solutions. We then introduce a differential testing approach, implemented in a framework named WasmChecker, to investigate the semantics equivalency of code between native x86-64 and WebAssembly binaries. Using WasmChecker, we provide a witness that WebAssembly compilers do not necessarily preserve code semantics when cross-compiling high-level language code into WebAssembly due to different implementations of standard libraries, unsupported system calls/APIs, WebAssembly's unique features, and compiler bugs. Furthermore, we have identified 11 new bugs in the Emscripten compiler toolchain, all confirmed by Emscripten developers. As proof of concept, we make our framework and the collected dataset of open-source codebases publicly available.

• The paper introduces WasmChecker, a differential testing framework used to identify challenges in cross-compiling legacy code to WebAssembly and preserving its semantics.
• Significant challenges in cross-compilation include unsupported system features, third-party library dependencies, and compiler incompatibilities.
• Semantic divergences in WebAssembly binaries result from standard library differences, unsupported APIs, Wasm constraints, and compiler bugs, highlighting the need for compiler improvements.

Analyzing the Challenges of Reusing Legacy Code in WebAssembly: Cross-Compilation and Code Semantics Preservation

The paper "Reusing Legacy Code in WebAssembly: Key Challenges of Cross-Compilation and Code Semantics Preservation" addresses critical aspects of using WebAssembly (Wasm) as a means to leverage legacy C/C++ codebases in modern web applications. Wasm is a statically typed binary instruction format designed to serve as a portable compilation target for high-level languages, promising near-native execution speeds within web browsers. The research scrutinizes two primary inquiries: the challenges inherent in cross-compiling legacy code into Wasm and the degree of semantic fidelity WebAssembly compilers maintain during this process.

Key Contributions and Findings

The paper introduces WasmChecker, a differential testing framework designed to evaluate the semantic equivalence between code compiled into native x86-64 binaries and Wasm binaries. The framework leverages open-source test cases to systematically assess whether functional behaviors align across the different platforms.

Challenges in Cross-Compilation

1. Undefined Symbols: A prevalent issue when cross-compiling occurs due to unsupported or non-emulated system-specific features, such as Stack Smashing Protection (SSP) mechanisms and some POSIX APIs, which are not fully supported by Emscripten—the primary compiler used for generating Wasm binaries from C/C++ code.
2. Third-party Library Dependencies: The availability and compatibility of third-party libraries are often limited, necessitating either manual porting or reliance on pre-ported libraries via platforms like emscripten-ports.
3. Compiler Options Incompatibility: Certain optimization and architecture-specific compilation flags common in traditional C/C++ compilers (e.g., GCC) do not translate to Emscripten. Adjustments or omissions are typically required to build Wasm binaries successfully.
4. Platform-Specific Code: Architecture-specific inline assembly code and platform-dependent features can prevent successful cross-compilation, requiring significant code refactoring.
5. WebAssembly Compiler Bugs: Despite advancements in WebAssembly compilation, compiler bugs still persist, occasionally thwarting even straightforward compilation processes.

Semantics Preservation and Test Findings

WasmChecker was tested on 115 projects, out of which it successfully compiled 99 into Wasm binaries, demonstrating its prowess in resolving basic build issues and mitigating certain runtime failures through appropriate settings. However, significant cases of semantic divergence were observed due to:

• Standard Library Variances: Differences in implementations between standard libraries used by WebAssembly compilers and native C/C++ compilers can cause behavioral discrepancies.
• Unsupported System Calls and APIs: The limited emulation of certain system-level APIs results in runtime failures or inconsistencies in WebAssembly.
• WebAssembly's Language Constraints: The constraints introduced by WebAssembly's design, such as dynamic type checking of function signatures, can create runtime discrepancies not present in traditional binaries.
• Compiler Limitations and Bugs: Unresolved bugs in the WebAssembly compilers can further distort code behavior, manifesting as semantic mismatches during execution.

Implications and Future Directions

The research underscores the necessity for improvements in WebAssembly compilers to fully realize the potential of code reusability without sacrificing performance or reliability. The findings highlight the need for robust runtime support in terms of standardized library implementations and system call resolutions. Furthermore, the paper points toward future work in enhancing source-level transformations to seamlessly adapt legacy code for the WebAssembly environment.

By elucidating these core challenges and proposing WasmChecker as a practical tool for semantic analysis, the paper lays foundational knowledge and provides resources for academia and industry to further the integration of legacy code into the web through WebAssembly. This advancement is crucial for expanding Wasm's application beyond the browser, into fields like edge computing, IoT, and smart contracts, where legacy codebases offer significant untapped potential.