Towards a Transpiler for C/C++ to Safer Rust (2401.08264v1)

Abstract: Rust is a multi-paradigm programming language developed by Mozilla that focuses on performance and safety. Rust code is arguably known best for its speed and memory safety, a property essential while developing embedded systems. Thus, it becomes one of the alternatives when developing operating systems for embedded devices. How to convert an existing C++ code base to Rust is also gaining greater attention. In this work, we focus on the process of transpiling C++ code to a Rust codebase in a robust and safe manner. The manual transpilation process is carried out to understand the different constructs of the Rust language and how they correspond to C++ constructs. Based on the learning from the manual transpilation, a transpilation table is created to aid in future transpilation efforts and to develop an automated transpiler. We also studied the existing automated transpilers and identified the problems and inefficiencies they involved. The results of the transpilation process were closely monitored and evaluated, showing improved memory safety without compromising performance and reliability of the resulting codebase. The study concludes with a comprehensive analysis of the findings, an evaluation of the implications for future research, and recommendations for the same in this area.

• The paper introduces a manual transpilation framework from C/C++ to Rust, addressing key limitations of existing automated tools.
• The approach maps complex C++ constructs to Rust’s safe paradigms, achieving memory safety without sacrificing system-level performance.
• The study lays foundational insights for future development of automated transpilers and safer systems programming practices.

Towards a Transpiler for C/C++ to Safer Rust: An Overview

This paper addresses the development of a transpilation process from C/C++ to Rust, aiming to leverage Rust's memory safety features while maintaining performance. Rust, known for its memory safety and speed without a garbage collector, presents a compelling option for systems programming and migrating existing infrastructure. The authors detail their approach to manual transpilation, proposing a framework for future automated tools.

Key Concepts and Evaluation of Existing Tools

The authors begin by examining the limitations of current automated transpilation tools such as C2Rust, bindgen, and CRust. They identify several issues:

• C2Rust: While capable of C to Rust conversion, the output remains unsafe, necessitating significant manual refinement (90-95% effort).
• bindgen: Focused on creating FFI bindings, it does not function as a transpiler.
• CRust: Although handling basic C/C++ constructs, it struggles with class conversions, header files, and pointers, requiring manual intervention for comprehensive translation.

These findings underscore the inadequacy of existing solutions for robust C++ to Rust transpilation, particularly for complex codebases like Tizen's gperf module—used as a case paper for its significance in smart device systems.

Manual Transpilation Process

Understanding the limitations of automated tools, the authors manually transcribed the gperf module, establishing a mapping between C++ and Rust constructs. Key challenges included:

• Class and Inheritance Handling: Rust's lack of direct inheritance requires alternative approaches using traits and composition.
• Pointer Safety: Transition from raw pointers in C++ to Rust's safe ownership and borrowing model.
• Functional Constructs: Adapting C++'s function overloading and inline functions within Rust's constraints.

Their manual approach led to the creation of a transpilation table, providing insights into mappings from C++ constructs to Rust equivalents.

Results and Implications

The manually transpiled Rust version of gperf demonstrated improved memory safety without sacrificing performance, as benchmark comparisons indicated. The Rust code in release mode often outperformed or matched the optimized C++ code. This suggests that Rust can offer equivalent system-level performance benefits while enhancing safety—a critical consideration for embedded systems like Tizen OS.

Potential Implications and Future Work

The proposed transpilation approach has significant implications, pointing towards potential development of an automated transpiler that could handle C++ to Rust transformations effectively. Key advancements in handling OOP features and memory management constructs in Rust could lead to wider adoption across industries reliant on C/C++ infrastructures.

Conclusion

In summary, this paper elucidates the complexities of transpiling C++ to Rust, providing a comprehensive manual framework while highlighting the limitations of existing tools. The insights offered into language mapping lay groundwork for future automation efforts, potentially driving safer, more efficient systems programming practices.