Handle comparisons against translated functions

cpp2rust/converter/converter.cpp

@@ -1430,7 +1430,7 @@ void Converter::EmitFnPtrCall(clang::Expr *callee) {
 
 void Converter::ConvertFunctionToFunctionPointer(
     const clang::FunctionDecl *fn_decl) {
-  StrCat(std::format("Some({})", GetNamedDeclAsString(fn_decl)));
+  StrCat(std::format("Some({})", Mapper::MapFunctionName(fn_decl)));
 }
 
 void Converter::ConvertGenericCallExpr(clang::CallExpr *expr) {
@@ -2070,7 +2070,7 @@ std::string Converter::ConvertDeclRefExpr(clang::DeclRefExpr *expr) {
   }
 
   auto *decl = expr->getDecl();
-  if (Mapper::Contains(expr)) {
+  if (ShouldReplaceWithMappedBody(expr)) {
     return GetMappedAsString(expr);
   } else if (auto *function = decl->getAsFunction()) {
     if (auto method = clang::dyn_cast<clang::CXXMethodDecl>(function)) {
@@ -3472,6 +3472,13 @@ bool Converter::isCallee() const {
   return !curr_expr_kind_.empty() && curr_expr_kind_.back() == ExprKind::Callee;
 }
 
+bool Converter::ShouldReplaceWithMappedBody(clang::DeclRefExpr *expr) const {
+  if (clang::isa<clang::FunctionDecl>(expr->getDecl()) && isAddrOf()) {
+    return false;
+  }
+  return Mapper::Contains(expr);
+}
+
 void Converter::SetFresh() {
   switch (computed_expr_type_) {
   case ComputedExprType::Value:

cpp2rust/converter/converter.h

@@ -459,6 +459,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool RecordDerivesDefault(const clang::RecordDecl *decl);
 
+  bool ShouldReplaceWithMappedBody(clang::DeclRefExpr *expr) const;
+
   std::string *rs_code_;
   clang::ASTContext &ctx_;
   clang::FunctionDecl *curr_function_ = nullptr;

cpp2rust/converter/converter_lib.cpp

@@ -8,7 +8,9 @@
 #include <clang/AST/ParentMapContext.h>
 #include <clang/Basic/SourceManager.h>
 
+#include <algorithm>
 #include <array>
+#include <cctype>
 #include <filesystem>
 #include <unordered_set>
 
@@ -660,4 +662,22 @@ clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx) {
       /*BasePath=*/nullptr, clang::VK_PRValue, clang::FPOptionsOverride());
 }
 
+static std::string_view Trim(std::string_view s) {
+  auto is_space = [](unsigned char c) { return std::isspace(c); };
+  auto b = std::find_if_not(s.begin(), s.end(), is_space);
+  auto e = std::find_if_not(s.rbegin(), s.rend(), is_space).base();
+  return {b, e};
+}
+
+void Unwrap(std::string &s, std::string_view prefix, std::string_view suffix) {
+  auto trimmed = Trim(s);
+  if (trimmed.starts_with(prefix) && trimmed.ends_with(suffix)) {
+    assert(trimmed.size() >= prefix.size() + suffix.size() &&
+           "prefix and suffix overlap in s");
+    trimmed.remove_prefix(prefix.size());
+    trimmed.remove_suffix(suffix.size());
+    s = std::string(trimmed);
+  }
+}
+
 } // namespace cpp2rust

cpp2rust/converter/converter_lib.h

@@ -12,6 +12,7 @@
 #include <optional>
 #include <regex>
 #include <string>
+#include <string_view>
 #include <vector>
 
 namespace cpp2rust {
@@ -154,4 +155,6 @@ bool ContainsVAArgExpr(const clang::Stmt *stmt);
 
 clang::Expr *CreateConversionToBool(clang::Expr *expr, clang::ASTContext &ctx);
 
+void Unwrap(std::string &s, std::string_view prefix, std::string_view suffix);
+
 } // namespace cpp2rust

cpp2rust/converter/mapper.cpp

@@ -8,6 +8,7 @@
 #include <llvm/Support/ThreadPool.h>
 
 #include <atomic>
+#include <format>
 #include <mutex>
 #include <regex>
 #include <utility>
@@ -581,6 +582,15 @@ const TranslationRule::ExprTgt *GetExprTgt(const clang::Expr *expr) {
   return nullptr;
 }
 
+std::string MapFunctionName(const clang::FunctionDecl *decl) {
+  assert(decl);
+  if (exprs_.contains(ToString(decl))) {
+    return std::format("libcc2rs::{}_{}", decl->getNameAsString(),
+                       model_ == Model::kRefCount ? "refcount" : "unsafe");
+  }
+  return GetNamedDeclAsString(decl->getCanonicalDecl());
+}
+
 std::string InstantiateTemplate(const clang::Expr *expr,
                                 const std::string &text) {
   auto it = search(expr);

cpp2rust/converter/mapper.h

@@ -31,6 +31,7 @@ bool Contains(const clang::Expr *expr);
 
 std::string Map(clang::QualType qual_type);
 const TranslationRule::ExprTgt *GetExprTgt(const clang::Expr *expr);
+std::string MapFunctionName(const clang::FunctionDecl *decl);
 std::string InstantiateTemplate(const clang::Expr *expr,
                                 const std::string &text);
 bool ReturnsPointer(const clang::Expr *expr);

cpp2rust/converter/models/converter_refcount.cpp

@@ -195,7 +195,7 @@ std::string ConverterRefCount::BuildFnAdapter(
   closure += "{ ";
 
   // Build adapter body: src_fn(convert(a0), convert(a1), ...)
-  closure += GetNamedDeclAsString(src_fn) + "(";
+  closure += Mapper::MapFunctionName(src_fn) + '(';
   for (unsigned i = 0; i < src_proto->getNumParams(); ++i) {
     auto src_pty = src_proto->getParamType(i);
     auto tgt_pty = target_proto->getParamType(i);
@@ -204,12 +204,12 @@ std::string ConverterRefCount::BuildFnAdapter(
     } else if (src_pty->isPointerType() && tgt_pty->isPointerType()) {
       if (tgt_pty->isVoidPointerType()) {
         closure += std::format("a{}.cast::<{}>().unwrap()", i,
-                               ToString(src_pty->getPointeeType()));
+                               ConvertPointeeType(src_pty));
       } else if (src_pty->isVoidPointerType()) {
         closure += std::format("a{}.to_any()", i);
       } else if (tgt_pty->getPointeeType()->isCharType()) {
         closure += std::format("a{}.reinterpret_cast::<{}>()", i,
-                               ToString(src_pty->getPointeeType()));
+                               ConvertPointeeType(src_pty));
       } else if (src_pty->getPointeeType()->isCharType()) {
         closure += std::format("a{}.reinterpret_cast::<u8>()", i);
       }
@@ -625,7 +625,7 @@ bool ConverterRefCount::VisitDeclRefExpr(clang::DeclRefExpr *expr) {
     }
   }
 
-  if (Mapper::Contains(expr)) {
+  if (ShouldReplaceWithMappedBody(expr)) {
     StrCat(GetMappedAsString(expr));
     return false;
   }
@@ -1037,7 +1037,7 @@ void ConverterRefCount::ConvertFunctionToFunctionPointer(
   StrCat(std::format("FnPtr::<{}>::new({})",
                      ConvertFunctionPointerType(
                          fn_decl->getType()->getAs<clang::FunctionProtoType>()),
-                     GetNamedDeclAsString(fn_decl)));
+                     Mapper::MapFunctionName(fn_decl)));
 }
 
 void ConverterRefCount::ConvertEqualsNullPtr(clang::Expr *expr) {
@@ -2155,4 +2155,18 @@ std::string ConverterRefCount::ConvertMappedMethodCall(
   return std::format("{}.with_mut(|__v: {}| __v{})", ptr, param_type, body);
 }
 
+std::string ConverterRefCount::ConvertPointeeType(clang::QualType ptr_type) {
+  if (ptr_type->getPointeeType()->isIntegerType()) {
+    return ToString(ptr_type->getPointeeType());
+  }
+
+  // Pointee of a pointer to incomplete type is an incomplete type that does
+  // not have a translation rule. Hence ToString(ptr_type->getPointeeType()) is
+  // not enough
+  assert(ptr_type->isPointerType());
+  auto str = ToString(ptr_type);
+  Unwrap(str, "Ptr<", ">");
+  return str;
+}
+
 } // namespace cpp2rust

cpp2rust/converter/models/converter_refcount.h

@@ -204,6 +204,7 @@ class ConverterRefCount final : public Converter {
   std::string ConvertFreshPointer(clang::Expr *expr) override;
 
   std::string ConvertPtrType(clang::QualType type);
+  std::string ConvertPointeeType(clang::QualType ptr_type);
 
   /// The kind of conversion that should be performed.
   enum class ConversionKind : uint8_t {

libcc2rs/src/io.rs

@@ -1,7 +1,7 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-use crate::{AsPointer, Ptr, Value};
+use crate::{AnyPtr, AsPointer, Ptr, Value};
 use std::cell::{RefCell, UnsafeCell};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
@@ -58,3 +58,83 @@ pub unsafe fn cout_unsafe() -> *mut std::fs::File {
 pub unsafe fn cerr_unsafe() -> *mut std::fs::File {
     UNSAFE_STDERR.with(UnsafeCell::get)
 }
+
+pub fn fread_refcount(a0: AnyPtr, a1: u64, a2: u64, a3: Ptr<::std::fs::File>) -> u64 {
+    let total = a1.saturating_mul(a2) as usize;
+    let mut dst = a0
+        .cast::<u8>()
+        .expect("fread: only supporting u8 pointers")
+        .clone();
+
+    let f = (*a3.upgrade().deref())
+        .try_clone()
+        .expect("try_clone failed");
+    let mut reader = std::io::BufReader::with_capacity(64 * 1024, f);
+
+    let mut read_bytes: usize = 0;
+    let mut buffer: [u8; 8192] = [0; 8192];
+
+    while read_bytes < total {
+        let remaining = total - read_bytes;
+        let to_read = std::cmp::min(buffer.len(), remaining);
+
+        let n = match std::io::Read::read(&mut reader, &mut buffer[..to_read]) {
+            Ok(0) => break,
+            Ok(n) => n,
+            Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
+            Err(e) => panic!("Unhandled error in fread: {e}"),
+        };
+
+        for &byte in &buffer[..n] {
+            dst.write(byte);
+            dst = dst.offset(1);
+        }
+
+        read_bytes += n;
+    }
+
+    (read_bytes / a1 as usize) as u64
+}
+
+/// # Safety
+///
+/// `a0` must point to a writable buffer of at least `a1 * a2` bytes, and `a3`
+/// must point to a valid, open `std::fs::File`.
+pub unsafe fn fread_unsafe(
+    a0: *mut ::std::ffi::c_void,
+    a1: u64,
+    a2: u64,
+    a3: *mut ::std::fs::File,
+) -> u64 {
+    let total = a1.saturating_mul(a2) as usize;
+    let mut dst = a0 as *mut u8;
+
+    let f = unsafe { (*a3).try_clone().expect("try_clone failed") };
+    let mut reader = std::io::BufReader::with_capacity(64 * 1024, f);
+
+    let mut read_bytes: usize = 0;
+    let mut buffer: [u8; 8192] = [0; 8192];
+
+    while read_bytes < total {
+        let remaining = total - read_bytes;
+        let to_read = std::cmp::min(buffer.len(), remaining);
+
+        let n = match std::io::Read::read(&mut reader, &mut buffer[..to_read]) {
+            Ok(0) => break,
+            Ok(n) => n,
+            Err(ref e) if e.kind() == std::io::ErrorKind::Interrupted => continue,
+            Err(e) => panic!("Unhandled error in fread: {e}"),
+        };
+
+        for &byte in &buffer[..n] {
+            unsafe {
+                *dst = byte;
+                dst = dst.offset(1);
+            }
+        }
+
+        read_bytes += n;
+    }
+
+    (read_bytes / a1 as usize) as u64
+}