gccrs: Introduce CStr language item

gcc/rust/ChangeLog:
	* util/rust-lang-item.h (LangItem::Kind): New CSTR kind.
	* util/rust-lang-item.cc (LangItem::lang_items): Ditto.
	* backend/rust-compile-type.cc (visit(TyTy::ReferenceType)): Add specific record
	type for CStr.
	* typecheck/rust-tyty.h (ReferenceType): Add function definition for is_dyn_cstr_type.
	* typecheck/rust-tyty.cc (ReferenceType::is_dyn_object): Update to include
	is_dyn_cstr_type.
	(ReferenceType::is_dyn_cstr_type): Add implementation to check whether the
	ReferenceType is of type CStr.
	* typecheck/rust-hir-type-check-base.cc(resolve_literal): Update C_STRING case to
	resolve to the CStr language item instead.

gcc/testsuite/ChangeLog:
	* rust/execute/torture/c_string.rs: Add CStr language item definition.
	* rust/compile/c_string_null_byte_check.rs: Ditto.

Signed-Off-By: Yap Zhi Heng <yapzhhg@gmail.com>

Author: Polygonalr

gcc/rust/backend/rust-compile-type.cc

@@ -650,6 +650,7 @@ TyTyResolveCompile::visit (const TyTy::ReferenceType &type)
   const TyTy::SliceType *slice = nullptr;
   const TyTy::StrType *str = nullptr;
   const TyTy::DynamicObjectType *dyn = nullptr;
+  const TyTy::ADTType *adt = nullptr;
   if (type.is_dyn_slice_type (&slice))
     {
       tree type_record = create_slice_type_record (*slice);
@@ -684,6 +685,28 @@ TyTyResolveCompile::visit (const TyTy::ReferenceType &type)
 
       return;
     }
+  // Check for CStr, create a specific record for it
+  else if (type.is_dyn_cstr_type (&adt))
+    {
+      // CStr in core crate is defined as the following:
+      //
+      // #[repr(transparent)]
+      // pub struct CStr {
+      //    inner: [u8]
+      // }
+      //
+      // Reuse the c_char (u8) slice fat-pointer layout
+      TyTy::BaseType *u8 = nullptr;
+      ctx->get_tyctx ()->lookup_builtin ("u8", &u8);
+      // Create a synthetic SliceType over u8 and use that record layout
+      TyTy::SliceType synthetic_slice (adt->get_ref (), adt->get_ident ().locus,
+				       TyTy::TyVar (u8->get_ref ()));
+      tree type_record = create_slice_type_record (synthetic_slice);
+      translated
+	= Backend::named_type ("&CStr", type_record, adt->get_ident ().locus);
+
+      return;
+    }
 
   tree base_compiled_type
     = TyTyResolveCompile::compile (ctx, type.get_base (), trait_object_mode);

gcc/rust/typecheck/rust-hir-type-check-base.cc

@@ -397,24 +397,28 @@ TypeCheckBase::resolve_literal (const Analysis::NodeMapping &expr_mappings,
 	    break;
 	  }
 
-	/* This is a pointer to a null-terminated byte slice (&[u8]). */
-	TyTy::BaseType *u8;
-	auto ok = context->lookup_builtin ("u8", &u8);
-	rust_assert (ok);
+	auto lang_item_defined
+	  = mappings.lookup_lang_item (LangItem::Kind::CSTR);
 
-	auto crate_num = mappings.get_current_crate ();
-	Analysis::NodeMapping slice_mapping (crate_num, UNKNOWN_NODEID,
-					     mappings.get_next_hir_id (
-					       crate_num),
-					     UNKNOWN_LOCAL_DEFID);
+	if (!lang_item_defined)
+	  {
+	    rust_error_at (locus, "unable to find lang item: %<c_str%>");
+	    infered = new TyTy::ErrorType (expr_mappings.get_hirid (), locus);
+	    break;
+	  }
 
-	TyTy::SliceType *slice
-	  = new TyTy::SliceType (slice_mapping.get_hirid (), locus,
-				 TyTy::TyVar (u8->get_ref ()));
-	context->insert_type (slice_mapping, slice);
+	DefId cstr_defid = lang_item_defined.value ();
+	HIR::Item *item = mappings.lookup_defid (cstr_defid).value ();
+
+	TyTy::BaseType *item_type = nullptr;
+	bool ok = context->lookup_type (item->get_mappings ().get_hirid (),
+					&item_type);
+
+	rust_assert (ok);
+	rust_assert (item_type->get_kind () == TyTy::TypeKind::ADT);
 
 	infered = new TyTy::ReferenceType (expr_mappings.get_hirid (),
-					   TyTy::TyVar (slice->get_ref ()),
+					   TyTy::TyVar (item_type->get_ref ()),
 					   Mutability::Imm,
 					   TyTy::Region::make_static ());
       }

gcc/rust/typecheck/rust-tyty.cc

@@ -3085,7 +3085,8 @@ ReferenceType::get_region () const
 bool
 ReferenceType::is_dyn_object () const
 {
-  return is_dyn_slice_type () || is_dyn_str_type () || is_dyn_obj_type ();
+  return is_dyn_slice_type () || is_dyn_str_type () || is_dyn_obj_type ()
+	 || is_dyn_cstr_type ();
 }
 
 bool
@@ -3127,6 +3128,27 @@ ReferenceType::is_dyn_obj_type (const TyTy::DynamicObjectType **dyn) const
   return true;
 }
 
+bool
+ReferenceType::is_dyn_cstr_type (const TyTy::ADTType **adt) const
+{
+  if (get_base ()->get_kind () != TyTy::TypeKind::ADT)
+    return false;
+
+  const TyTy::ADTType *adt_ty
+    = static_cast<const TyTy::ADTType *> (get_base ());
+  auto &mappings = Analysis::Mappings::get ();
+  auto cstr_item = mappings.lookup_lang_item (LangItem::Kind::CSTR);
+
+  if (!cstr_item.has_value ())
+    return false;
+
+  if (cstr_item.value () != adt_ty->get_id ())
+    return false;
+
+  *adt = adt_ty;
+  return true;
+}
+
 void
 ReferenceType::accept_vis (TyVisitor &vis)
 {

gcc/rust/typecheck/rust-tyty.h

@@ -1693,6 +1693,7 @@ class ReferenceType : public BaseType
   bool is_dyn_slice_type (const TyTy::SliceType **slice = nullptr) const;
   bool is_dyn_str_type (const TyTy::StrType **str = nullptr) const;
   bool is_dyn_obj_type (const TyTy::DynamicObjectType **dyn = nullptr) const;
+  bool is_dyn_cstr_type (const TyTy::ADTType **adt = nullptr) const;
 
 private:
   TyVar base;

gcc/rust/util/rust-lang-item.cc

@@ -92,6 +92,9 @@ const BiMap<std::string, LangItem::Kind> Rust::LangItem::lang_items = {{
   {"slice_u8", Kind::SLICE_U8},
   {"slice", Kind::SLICE},
   {"str", Kind::STR},
+  // NOTE: CStr is not present in Rust 1.49, and is only backported for
+  // compilation of Rust for Linux with a patched core lib.
+  {"CStr", Kind::CSTR},
   {"f32_runtime", Kind::F32_RUNTIME},
   {"f64_runtime", Kind::F64_RUNTIME},
 

gcc/rust/util/rust-lang-item.h

@@ -125,6 +125,9 @@ class LangItem
     SLICE_U8,
     SLICE,
     STR,
+    // NOTE: CStr is not present in Rust 1.49, and is only backported for
+    // compilation of Rust for Linux with a patched core lib.
+    CSTR,
     F32_RUNTIME,
     F64_RUNTIME,
 

gcc/testsuite/rust/compile/c_string_null_byte_check.rs

@@ -1,7 +1,20 @@
 // { dg-additional-options "-frust-c-style-string-literals" }
-#![feature(no_core)]
+#![feature(no_core, lang_items)]
 #![no_core]
 
+type c_char = u8;
+
+#[lang = "CStr"]
+pub struct CStr {
+    inner: [c_char]
+}
+
+impl CStr {
+    pub const fn to_ptr(&self) -> *const c_char {
+        &self.inner as *const [c_char] as *const c_char
+    }
+}
+
 pub fn main() {
     let _fail = c"gc\0crs";
     // { dg-error "null characters in C string literals are not supported" "" { target *-*-* } .-1 }

gcc/testsuite/rust/execute/torture/c_string.rs

@@ -1,15 +1,28 @@
 // { dg-additional-options "-frust-c-style-string-literals" }
 // { dg-output "gccrs\n" }
-#![feature(no_core)]
+#![feature(no_core, lang_items)]
 #![no_core]
 
 extern "C" {
-    fn printf(s: *const i8, ...);
+    fn printf(s: *const u8, ...);
+}
+
+type c_char = u8;
+
+#[lang = "CStr"]
+pub struct CStr {
+    inner: [c_char]
+}
+
+impl CStr {
+    pub const fn to_ptr(&self) -> *const c_char {
+        &self.inner as *const [c_char] as *const c_char
+    }
 }
 
 pub fn main() {
     let a = c"gccrs";
     unsafe {
-        printf(a as *const [u8] as *const i8); // TODO change `as *const [u8]` to `.as_ptr()` when C strings are compiled to their own CStr type
+        printf(a.to_ptr());
     }
 }