transpile: Use literal directly when taking address of string literal

Author: Rua

c2rust-transpile/src/translator/operators.rs

@@ -938,10 +938,10 @@ impl<'c> Translation<'c> {
                 // In this translation, there are only pointers to functions and
                 // & becomes a no-op when applied to a function.
 
-                let arg = self.convert_expr(ctx.used().set_needs_address(true), arg, None)?;
+                let val = self.convert_expr(ctx.used().set_needs_address(true), arg, None)?;
 
                 if self.ast_context.is_function_pointer(ctype) {
-                    Ok(arg.map(|x| mk().call_expr(mk().ident_expr("Some"), vec![x])))
+                    Ok(val.map(|x| mk().call_expr(mk().ident_expr("Some"), vec![x])))
                 } else {
                     let pointee_ty =
                         self.ast_context
@@ -950,13 +950,57 @@ impl<'c> Translation<'c> {
                                 TranslationError::generic("Address-of should return a pointer")
                             })?;
 
+                    let expr_kind = &self.ast_context.index(arg).kind;
+                    let translate_as_macro = self
+                        .convert_const_macro_expansion(ctx, arg, None)
+                        .ok()
+                        .flatten()
+                        .is_some();
+
+                    // String literals are translated with a transmute, which produces a temporary.
+                    // Taking the address of a temporary leaves a dangling pointer. So instead,
+                    // cast the string literal directly so that its 'static lifetime is preserved.
+                    if let (
+                        &CExprKind::Literal(
+                            literal_cqual_type,
+                            CLiteral::String(ref bytes, element_size @ 1),
+                        ),
+                        false,
+                    ) = (expr_kind, translate_as_macro)
+                    {
+                        let num_elems =
+                            match self.ast_context.resolve_type(literal_cqual_type.ctype).kind {
+                                CTypeKind::ConstantArray(_, num_elems) => num_elems,
+                                ref kind => {
+                                    panic!(
+                                    "String literal with unknown size: {bytes:?}, kind = {kind:?}"
+                                )
+                                }
+                            };
+
+                        // Match the literal size to the expected size padding with zeros as needed
+                        let size = num_elems * (element_size as usize);
+                        let mut bytes_padded = Vec::with_capacity(size);
+                        bytes_padded.extend(bytes);
+                        bytes_padded.resize(size, 0);
+
+                        let array_ty = mk().array_ty(
+                            mk().ident_ty("u8"),
+                            mk().lit_expr(bytes_padded.len() as u128),
+                        );
+                        let bytes_literal = mk().lit_expr(bytes_padded);
+                        let val = mk().cast_expr(bytes_literal, mk().ptr_ty(array_ty));
+                        let val = mk().cast_expr(val, ty);
+                        return Ok(WithStmts::new_val(val));
+                    }
+
                     let mutbl = if pointee_ty.qualifiers.is_const {
                         Mutability::Immutable
                     } else {
                         Mutability::Mutable
                     };
 
-                    arg.result_map(|a| {
+                    val.result_map(|a| {
                         let mut addr_of_arg: Box<Expr>;
 
                         if ctx.is_static {

c2rust-transpile/tests/snapshots/[email protected]

@@ -86,13 +86,12 @@ pub unsafe extern "C" fn entry() {
     let mut const_char_lit_ptr: *const ::core::ffi::c_char =
         b"abc\0" as *const u8 as *const ::core::ffi::c_char;
     let mut const_char_lit_array_ptr: *const [::core::ffi::c_char; 4] =
-        &::core::mem::transmute::<[u8; 4], [::core::ffi::c_char; 4]>(*b"abc\0")
-            as *const [::core::ffi::c_char; 4];
+        b"abc\0" as *const [u8; 4] as *const [::core::ffi::c_char; 4];
     let mut char_lit_ptr: *mut ::core::ffi::c_char =
         b"abc\0" as *const u8 as *const ::core::ffi::c_char as *mut ::core::ffi::c_char;
-    let mut char_lit_array_ptr: *mut [::core::ffi::c_char; 4] =
-        &::core::mem::transmute::<[u8; 4], [::core::ffi::c_char; 4]>(*b"abc\0")
-            as *const [::core::ffi::c_char; 4] as *mut [::core::ffi::c_char; 4];
+    let mut char_lit_array_ptr: *mut [::core::ffi::c_char; 4] = b"abc\0" as *const [u8; 4]
+        as *const [::core::ffi::c_char; 4]
+        as *mut [::core::ffi::c_char; 4];
     let mut past_end: *mut ::core::ffi::c_char = &mut *simple
         .as_mut_ptr()
         .offset(::core::mem::size_of::<[::core::ffi::c_char; 9]>() as isize)