Handle comparisons against translated functions by lucic71 · Pull Request #3 · Cpp2Rust/cpp2rust

lucic71 · 2026-04-13T20:35:08Z

This PR adds support for translating comparisons against functions that have translation rules fn_ptr == translated_rule, for example in fn1 == fread in fn_ptr_stdlib_compare.cpp:

fn1 == 
  FnPtr::new<fn(AnyPtr, u64, u64, Ptr<::std::fs::File>) -> u64>(
    libcc2rs::fread_refcount)

Non-capturing lambdas are translated as Option<fn>, same as free functions, because they can be decayed to free functions. Capturing lambdas remain Rc<dyn Fn>.

Previously function pointers were modeled as Option<fn>, but this is problematic for function pointer casts. Option<fn> works well in unsafe with std::mem::transmute, however there is no safe way to achieve the same operation in refcount. This is solved using the new Ptr<fn>. To allow casting between different function types, use type erased Rc<dyn Any> inside the new PtrKind::Fn. Equality of function pointers is achieved through implementing the OriginalAlloc::address method. The C standard allows converting function pointers between incompatible function types. UB is triggered only when the incompatible pointer is called. For this reason the new FnState implements 2 new concepts: 1. casting adaptors (to allow argument casting between ABI compatible types) 2. provenance stack (to allow round-trip function pointer casts) For 1., consider the following cast: int fn_taking_int_ptr(int *p); int (*fn_taking_void_ptr)(void*) = (int (*)(void*))fn_taking_int_ptr; Calling fn_taking_int_ptr with an int* argument works because both int* and void* have the same size. To support this in Rust we need to create an int* -> void* adapter when casting from fn_taking_int_ptr to fn_taking_void_ptr: fn_taking_int_ptr.cast_fn::<fn(AnyPtr) -> i32>(Some( (|a0: AnyPtr| -> i32 { fn_taking_int_ptr(a0.cast::<i32>().unwrap()) }) as fn(AnyPtr) -> i32 )) The job of the adapter is to convert from AnyPtr to Ptr<i32>. Ptr::cast_fn is a new function that takes as type argument the type of the target function pointer and an optional adaptor. If cast_fn receives None, then there is no valid adaptor from source to target, matching the UB semantics of calling a function through an incompatible function pointer: int add(int a, int b) { return a + b; } void (*wrong)(void) = (void (*)(void))add; wrong() For 2., the provenance stack contains all casts performed on the pointer in the past. Compared to PtrKind::Reinterpreted, PtrKind::Fn has no backing byte storage through OriginalAlloc, so each cast must know its history in order to allow round-trip casts, such as: int (*)(int, int) -> void (*)(void) -> int (*)(int, int) (1) (2) For this specific case, where both (1) and (2) create non-compatible adaptors (because of non-compatible arguments), we cannot recover a call to the original function after (1) is performed. For this to work, save a stack of provenance, and when (2) is perfomed, cast_fn recovers the original function pointer. See test_roundtrip in fn_ptr_cast.cpp. A current limitation of this approach is that it only allows function pointer casts where the source is a direct declaration of a function. Accessing a function pointer through a member field for example, would create a capturing adapter which does not coerce in a fn inside Ptr<fn>.

Also make the rules public so that generated code can reference them.

lucic71 · 2026-04-20T16:40:36Z

@nunoplopes this is ready for review

nunoplopes · 2026-04-21T14:21:35Z

 }

-fn f5(a0: AnyPtr, a1: u64, a2: u64, a3: Ptr<::std::fs::File>) -> u64 {
+pub fn f5(a0: AnyPtr, a1: u64, a2: u64, a3: Ptr<::std::fs::File>) -> u64 {


why these changes?

To make f5 visible outside the crate so that translted code can take the address of this function: rules::stdio_tgt_refcount::f5

That's a major hack. No way this works. Rule's names are internal and should not be exported.
Translated programs only link with libcc2rs. Add new symbols there.

So generated code should use libcc2rs::fread instead of rules::stdio_tgt_refcount::f5? In this case libcc2rs::fread should be defined as a call to rules::stdio_tgt_refcount::f5. For this to work, I think making f5 public is still required

No, we should not export anything in rules. And should definitely not export a function named f5.
You need to create an fread function in libcc2rs.

We also need to support calling into mapped functions using function pointers, like:

auto fn = &fread; fn(...);

This means that the body of libcc2rs::fread and rules::stdio_tgt_refcount::f5 has to be exactly the same. Without exporting f5 from rules, we will copy-paste the body of rules::stdio_tgt_refcount::f5 inside libcc2rs::fread

That's ok for now. But we are not exporting the rules directory and f5 names.

I created fread_refcount and fread_unsafe. Generated code can use these functions for saving the address of fread. Generated code can also call into fread through a function pointer.

To avoid code duplication, the fread translation rules also call into fread_refcount and fread_unsafe

nunoplopes · 2026-04-23T08:27:40Z

+static void Trim(std::string &s) {
+  auto is_space = [](unsigned char c) { return std::isspace(c); };
+  s.erase(s.begin(), std::find_if_not(s.begin(), s.end(), is_space));
+  s.erase(std::find_if_not(s.rbegin(), s.rend(), is_space).base(), s.end());


instead of modifying the string, it's cheaper to do substr on a string_view

I moved to string_view

nunoplopes · 2026-04-23T08:28:19Z

+
+void Unwrap(std::string &s, std::string_view prefix, std::string_view suffix) {
+  Trim(s);
+  if (s.size() >= prefix.size() + suffix.size() && s.starts_with(prefix) &&


this size comparison is not needed, unless prefix and suffix might be the same?

I moved this check in an assert so that it only triggers in Debug builds

lucic71 marked this pull request as draft April 13, 2026 20:35

This comment was marked as outdated.

Sign in to view

lucic71 marked this pull request as ready for review April 15, 2026 14:49

lucic71 added 27 commits April 15, 2026 15:52

Translate free function ptr as Option<fn>

117afb3

Fix null ptr deref

562978b

Fix translation of lambdas

32ae03c

Non-capturing lambdas are translated as Option<fn>, same as free functions, because they can be decayed to free functions. Capturing lambdas remain Rc<dyn Fn>.

Translate type of lambda as _ instead of Rc<dyn Fn>

c431b29

Translate non-const globals as static mut

de96315

Use concerete default val for initializing globals

212d22b

Help the compiler deduce the type of a function

58c39b9

Don't add &mut in function ptr conditionals

12a4433

Add fn_ptr and lambda tests

7ab067d

clang-format

ddd13a8

Update tests

4d93cd4

clang-format

691a435

Translate fn ptr cast using mem::transmute

f026728

Move PtrKind::Fn into FnPtr

a5d65f6

Fix signature of fread and fwrite

01e9e9f

Also make the rules public so that generated code can reference them.

Add name and module in ExprTgt

e3a69af

Use rule function name in AddrOf context

e30fef0

Check name and module are never empty

133e94f

Get fully qualified name of translation rule

25b203f

Update output of fn_ptr_stdlib_compare

9cfda12

Change to deafult with suffix

06b73fd

Make rules public

942bde3

cargo-fmt

03e7ab7

Delete unused Cargo.toml

a2e1c1a

Use prebuilt rules and libcc2rs targets

1c1ab7d

Implement Deref for FnPtr

840863d

Add ConvertPointeeType

a929df9

lucic71 marked this pull request as ready for review April 20, 2026 16:34

Add ShouldReplaceWithMappedBody

1e0794a

lucic71 added 4 commits April 20, 2026 17:47

Replace single char strings with char literals

747195b

Short-circuit ConvertPointeeType for integer types

1645da1

Merge branch 'master' into fn-ptr

6455886

Update tests

2f7ce1b

nunoplopes reviewed Apr 21, 2026

View reviewed changes

Comment thread cpp2rust/converter/translation_rule.h Outdated

nunoplopes reviewed Apr 23, 2026

View reviewed changes

lucic71 added 16 commits April 24, 2026 09:25

Replace rules::stdio_tgt_unsafe::f5 with rules::fread_unsafe

83e8868

Merge branch 'master' into fn-ptr

f1ce30d

Revert translation_rule to master

81a2f40

Add fread alias for f5 rule

d7709d5

Add call to fread through function pointer

44a6d61

rustfmt

9b3b165

Move implementation of fread inside libcc2rs

06d80a3

Remove unused import

c6ab724

Update the IR

a689a25

Call fread both through func ptr and direct func call

ff7719a

Remove unintented generated files

b993692

Revert making rules visible

6234360

Delete unrelated file

3890493

Use strinv_view in Trim

49034f3

Move overlapping check in assert

7aa0fdb

Fix clippy errors

c6c7024

nunoplopes merged commit 370e554 into Cpp2Rust:master Apr 27, 2026
9 checks passed

lucic71 deleted the fn-ptr branch April 29, 2026 13:19

Conversation

lucic71 commented Apr 13, 2026 • edited Loading Uh oh! There was an error while loading. Please reload this page.

Uh oh!

Uh oh!

This comment was marked as outdated.

lucic71 commented Apr 20, 2026

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Choose a reason for hiding this comment

Uh oh!

Uh oh!

Reviewers

Assignees

Labels

Projects

Milestone

Development

Uh oh!

2 participants

lucic71 commented Apr 13, 2026 •

edited

Loading