Translating C to safer Rust

Emre, Mehmet; Schroeder, Ryan; Dewey, Kyle; Hardekopf, Ben

doi:10.1145/3485498

Cited by 22 publications

(12 citation statements)

References 26 publications

Supporting

Mentioning

Contrasting

Order By: Relevance

“…1) Transforming C2Rust-Generated Code: A few tools have been proposed to replace C features in C2Rust-Generated code with their counterparts in Rust, but they do not target the lock API. Emre et al [28] tackled replacing C pointers in Rust with Rust pointers. Their work also requires semantic information, but they focus on pointers and sequential programs.…”

Section: Related Workmentioning

confidence: 99%

Concrat: An Automatic C-to-Rust Lock API Translator for Concurrent Programs

Hong¹,

Ryu²

2023

Preprint

View full text Add to dashboard Cite

Concurrent programs suffer from data races. To prevent data races, programmers use locks. However, programs can eliminate data races only when they acquire and release correct locks at correct timing. The lock API of C, in which people have developed a large portion of legacy system programs, does not validate the correct use of locks. On the other hand, Rust, a recently developed system programming language, provides a lock API that guarantees the correct use of locks via type checking. This makes rewriting legacy system programs in Rust a promising way to retrofit safety into them. Unfortunately, manual C-to-Rust translation is extremely laborious due to the discrepancies between their lock APIs. Even the state-of-the-art automatic C-to-Rust translator retains the C lock API, expecting developers to replace them with the Rust lock API. In this work, we propose an automatic tool to replace the C lock API with the Rust lock API. It facilitates C-to-Rust translation of concurrent programs with less human effort than the current practice. Our tool consists of a Rust code transformer that takes a lock summary as an input and a static analyzer that efficiently generates precise lock summaries. We show that the transformer is scalable and widely applicable while preserving the semantics; it transforms 66 KLOC in 2.6 seconds and successfully handles 74% of real-world programs. We also show that the analyzer is scalable and precise; it analyzes 66 KLOC in 4.3 seconds. of the Linux kernel will support Rust code [23]. Android and Fuchsia implementations also use RustReimplementing concurrent programs in Rust is, however, labor-intensive if done manually. The discrepancies between the lock APIs of C and Rust hinder programmers from mechanical rewriting. They have to understand the use of the C lock API in original programs and restructure the programs to express the intended logic with the Rust lock API. It poses the necessity for a tool for automatic C-to-Rust translation.The state-of-the-art C-to-Rust translator, C2Rust [58], is still far from alleviating the burden on programmers. The translation of C2Rust is completely syntactic and generates Rust code using the C lock API. Programmers are expected to replace the C lock API in C2Rust-generated code with the Rust lock API for thread safety. While being better than nothing,

show abstract

Section: Related Workmentioning

confidence: 99%

Concrat: An Automatic C-to-Rust Lock API Translator for Concurrent Programs

Hong¹,

Ryu²

2023

Preprint

View full text Add to dashboard Cite

show abstract

“…During the transpilation of C libraries, c2rust treats each file as a separate compilation unit, which gets translated into a separate Rust module. Consequently, struct definitions are duplicated, and available function definitions are put in extern blocks [14]. We apply a preprocessing step similar to the resolve-imports tool of Laertes [14] that links those definitions across files.…”

Section: Preprocessingmentioning

confidence: 99%

“…In response to this demand, automated tools translating C code to Rust emerge from both industry and academia [14,21,26]. Among them, the industrial strength translator C2Rust [21] rewrites C code into the Rust syntax while preserving the original semantics.…”

Section: Introductionmentioning

confidence: 99%

“…More recent work focuses on reducing this unsafe labelling. In particular, the tool Laertes [14] aims to rewrite the (unsafe) code produced by C2Rust by searching the solution space guided by the type error messages from the Rust compiler. This is ground breaking, as for the first time proper Rust code beyond a line-by-line direct conversion from the original C source may be synthesised.…”

Section: Introductionmentioning

confidence: 99%

“…But there is more. In contrast to trying the Rust compiler as common in existing approaches [14,26], this analysis approach actually extracts new knowledge of ownership from code, which may lead to a range of utilities including preventing memory leaks, identifying inherently unsafe code fragments, detecting memory bugs, and so on. Specifically, in this paper we design a scalable and precise ownership analysis that is able to handle complex inductively-defined data structures and nested pointers.…”

Section: Introductionmentioning

confidence: 99%

See 2 more Smart Citations

Ownership guided C to Rust translation

Zhang¹,

David²,

Yu³

et al. 2023

Preprint

View full text Add to dashboard Cite

Dubbed a safer C, Rust is a modern programming language that combines memory safety and low-level control. This interesting combination has made Rust very popular among developers and there is a growing trend of migrating legacy codebases (very often in C) to Rust. In this paper, we present a C to Rust translation approach centred around static ownership analysis. We design a suite of analyses that infer ownership models of C pointers and automatically translate the pointers into safe Rust equivalents. The resulting tool, Crown, scales to realworld codebases (half a million lines of code in less than 10 seconds) and achieves a high conversion rate.

show abstract

On the Termination of Borrow Checking in Featherweight Rust

Payet

Pearce

Spoto

2022

Lecture Notes in Computer Science

View full text Add to dashboard Cite

A distinguished feature of the Rust programming language is its ability to deallocate dynamically-allocated data structures as soon as they go out of scope, without relying on a garbage collector. At the same time, Rust lets programmers create references, called borrows, to data structures. A static borrow checker enforces that borrows can only be used in a controlled way, so that automatic deallocation does not introduce dangling references. Featherweight Rust provides a formalisation for a subset of Rust where borrow checking is encoded using flow typing [25]. However, we have identified a source of non-termination within the calculus which arises when typing environments contain cycles between variables. In fact, it turns out that well-typed programs cannot lead to such environments -but this was not immediately obvious from the presentation. This paper defines a simplification of Featherweight Rust, more amenable to formal proofs. Then it develops a sufficient condition that forbids cycles and, hence, guarantees termination. Furthermore, it proves that this condition is, in fact, maintained by Featherweight Rust for welltyped programs.

show abstract

Translating C to safer Rust

Cited by 22 publications

References 26 publications

Concrat: An Automatic C-to-Rust Lock API Translator for Concurrent Programs

Concrat: An Automatic C-to-Rust Lock API Translator for Concurrent Programs

Ownership guided C to Rust translation

On the Termination of Borrow Checking in Featherweight Rust

Contact Info

Product

Resources

About