diff --git a/cpp2rust/converter/converter.cpp b/cpp2rust/converter/converter.cpp
index 98abbbaa..c287f319 100644
--- a/cpp2rust/converter/converter.cpp
+++ b/cpp2rust/converter/converter.cpp
@@ -123,8 +123,13 @@ bool Converter::VisitBuiltinType(clang::BuiltinType *type) {
     StrCat("f64");
     break;
   case clang::BuiltinType::Char_S:
-  case clang::BuiltinType::UChar:
+  case clang::BuiltinType::Char_U:
+    StrCat(CharRustType());
+    break;
   case clang::BuiltinType::SChar:
+    StrCat("i8");
+    break;
+  case clang::BuiltinType::UChar:
     StrCat("u8");
     break;
   case clang::BuiltinType::UShort:
@@ -1410,7 +1415,8 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
   } else if (arg_str.contains("Setw")) {
     fmt_width = Trim(ToString(arg));
   } else if (!arg->getType()->isCharType() &&
-             Mapper::Map(arg->getType()) != "Vec<u8>") {
+             Mapper::Map(arg->getType()) !=
+                 std::format("Vec<{}>", CharRustType())) {
     fmt += ("{:" + fmt_width + fmt_trait + "}");
     fmt_width.clear(); // Reset setw after first usage
     arg_str = ToString(arg);
@@ -1426,11 +1432,13 @@ bool Converter::GetFmtArg(clang::Expr *arg, std::string &fmt,
 
 bool Converter::GetRawArg(clang::Expr *arg, std::string &raw_args) {
   if (arg->getType()->isCharType()) {
-    raw_args += "(&[" + ToString(arg) + ']';
-  } else if (Mapper::Map(arg->getType()) == "Vec<u8>") {
+    raw_args += "(&[" + ToString(arg) + " as u8]";
+  } else if (Mapper::Map(arg->getType()) ==
+             std::format("Vec<{}>", CharRustType())) {
     PushExprKind push(*this, ExprKind::RValue);
     std::string str = ToString(arg);
-    raw_args += "(&(" + str + ")[..(" + str + ").len() - 1]";
+    raw_args += "(&(" + str + ").iter().take((" + str +
+                ").len() - 1).map(|&c| c as u8).collect::<Vec<u8>>()[..]";
   } else if (Mapper::ToString(arg).contains("std::endl")) {
     raw_args += "(&[b'\\n']";
   } else if (clang::isa<clang::StringLiteral>(arg->IgnoreImplicit())) {
@@ -1847,6 +1855,14 @@ Converter::ConvertCallExpr(clang::CallExpr *expr) {
   return std::nullopt;
 }
 
+static std::string getTypedLiteral(const char *num, std::string_view type) {
+  if (type.contains("::")) {
+    // Not a builtin type
+    return std::format("({} as {})", num, type);
+  }
+  return std::format("{}_{}", num, type);
+}
+
 std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
                                          bool incl_type,
                                          const clang::QualType *type) {
@@ -1868,7 +1884,7 @@ std::string Converter::getIntegerLiteral(clang::IntegerLiteral *expr,
         return init;
       }
     }
-    return std::format("{}_{}", num_as_string.c_str(), type_as_string);
+    return getTypedLiteral(num_as_string.c_str(), type_as_string);
   }
 
   return static_cast<std::string>(num_as_string);
@@ -1961,19 +1977,23 @@ bool Converter::VisitStringLiteral(clang::StringLiteral *expr) {
     if (auto *arr_ty = ctx_.getAsConstantArrayType(curr_init_type_.back())) {
       uint64_t arr_size = arr_ty->getSize().getZExtValue();
       if (expr->getString().empty()) {
-        StrCat(std::format("[0u8; {}]", arr_size));
+        StrCat(std::format("[0 as libc::c_char; {}]", arr_size));
         return false;
       }
       uint64_t pad = arr_size > expr->getString().size()
                          ? arr_size - expr->getString().size()
                          : 0;
-      StrCat(token::kStar,
-             std::format("b{}", GetEscapedStringLiteral(expr, pad)));
+      StrCat(std::format("std::mem::transmute(*b{})",
+                         GetEscapedStringLiteral(expr, pad)));
       return false;
     }
-    StrCat(token::kStar);
+    StrCat(std::format("std::mem::transmute(*b{})",
+                       GetEscapedStringLiteral(expr, 1)));
+    return false;
   }
-  StrCat(std::format("b{}", GetEscapedStringLiteral(expr, 1)));
+  assert(!expr->getString().contains('\0') &&
+         "interior null byte in string literal");
+  StrCat(std::format("c{}", GetEscapedStringLiteral(expr, 0)));
   return false;
 }
 
@@ -2056,15 +2076,6 @@ bool Converter::VisitImplicitCastExpr(clang::ImplicitCastExpr *expr) {
     }
     bool dest_pointee_const =
         expr->getType()->getPointeeType().isConstQualified();
-    if (const auto *member =
-            clang::dyn_cast<clang::MemberExpr>(sub_expr->IgnoreParenImpCasts());
-        member && IsCharArrayFieldFromLibc(member->getMemberDecl())) {
-      PushParen paren(*this);
-      Convert(sub_expr);
-      StrCat(dest_pointee_const ? ".as_ptr()" : ".as_mut_ptr()");
-      StrCat(keyword::kAs, dest_pointee_const ? "*const u8" : "*mut u8");
-      break;
-    }
     Convert(sub_expr);
     if (clang::isa<clang::StringLiteral>(sub_expr) ||
         clang::isa<clang::PredefinedExpr>(sub_expr)) {
@@ -2752,16 +2763,6 @@ bool Converter::VisitMemberExpr(clang::MemberExpr *expr) {
     return false;
   }
 
-  // char* fields in libc structs are *mut i8. We represent char* as *mut u8. Do
-  // the i8 -> u8 conversion here.
-  if (IsCharPointerFieldFromLibc(member)) {
-    StrCat(std::format("({} as {})", str,
-                       member->getType()->getPointeeType().isConstQualified()
-                           ? "*const u8"
-                           : "*mut u8"));
-    return false;
-  }
-
   StrCat(str);
   return false;
 }
@@ -3462,11 +3463,11 @@ std::string Converter::GetDefaultAsStringFallback(clang::QualType qual_type) {
   }
 
   if (qual_type->isIntegerType() && !qual_type->isEnumeralType()) {
-    return std::format("0_{}", ToString(qual_type));
+    return getTypedLiteral("0", ToString(qual_type));
   }
 
   if (qual_type->isFloatingType()) {
-    return std::format("0.0_{}", ToString(qual_type));
+    return getTypedLiteral("0.0", ToString(qual_type));
   }
 
   if (auto record = qual_type->getAsRecordDecl();
@@ -3781,7 +3782,7 @@ void Converter::ConvertFunctionMain(const clang::FunctionDecl *decl,
 pub fn main() {{
     let mut args: Vec<Vec<u8>> = std::env::args().map(|arg| arg.as_bytes().to_vec()).collect();
     args.iter_mut().for_each(|v| v.push(0));
-    let mut argv: Vec<*mut u8> = args.iter().map(|arg| arg.as_ptr() as *mut u8).collect();
+    let mut argv: Vec<*mut libc::c_char> = args.iter().map(|arg| arg.as_ptr() as *mut libc::c_char).collect();
     argv.push(::std::ptr::null_mut());
     unsafe {{
         ::std::process::exit(main_0((argv.len() - 1) as i32, argv.as_mut_ptr()) as i32)
diff --git a/cpp2rust/converter/converter.h b/cpp2rust/converter/converter.h
index 9c3fc5f1..08a4a827 100644
--- a/cpp2rust/converter/converter.h
+++ b/cpp2rust/converter/converter.h
@@ -116,6 +116,8 @@ class Converter : public clang::RecursiveASTVisitor<Converter> {
 
   virtual bool EmitsReprCForRecords() const { return true; }
 
+  virtual const char *CharRustType() const { return "libc::c_char"; }
+
   virtual bool VisitCXXMethodDecl(clang::CXXMethodDecl *decl);
   virtual std::string GetSelfMaybeWithMut(const clang::CXXMethodDecl *decl);
 
diff --git a/cpp2rust/converter/converter_lib.cpp b/cpp2rust/converter/converter_lib.cpp
index 1b837cd7..702e57ef 100644
--- a/cpp2rust/converter/converter_lib.cpp
+++ b/cpp2rust/converter/converter_lib.cpp
@@ -130,26 +130,6 @@ bool IsInMainFile(const clang::Decl *decl) {
   return src_mgr.isInMainFile(src_mgr.getExpansionLoc(loc));
 }
 
-bool IsCharPointerFieldFromLibc(const clang::ValueDecl *decl) {
-  auto field = clang::dyn_cast<clang::FieldDecl>(decl);
-  if (!field || !field->getType()->isPointerType() ||
-      !field->getType()->getPointeeType()->isCharType()) {
-    return false;
-  }
-  return field->getASTContext().getSourceManager().isInSystemHeader(
-      field->getParent()->getLocation());
-}
-
-bool IsCharArrayFieldFromLibc(const clang::ValueDecl *decl) {
-  auto field = clang::dyn_cast<clang::FieldDecl>(decl);
-  if (!field || !field->getType()->isArrayType() ||
-      !field->getType()->getArrayElementTypeNoTypeQual()->isCharType()) {
-    return false;
-  }
-  return field->getASTContext().getSourceManager().isInSystemHeader(
-      field->getParent()->getLocation());
-}
-
 bool IsUserDefinedDecl(const clang::Decl *decl) {
   const auto &ctx = decl->getASTContext();
   const auto &src_mgr = ctx.getSourceManager();
diff --git a/cpp2rust/converter/converter_lib.h b/cpp2rust/converter/converter_lib.h
index d652735e..8c281261 100644
--- a/cpp2rust/converter/converter_lib.h
+++ b/cpp2rust/converter/converter_lib.h
@@ -40,10 +40,6 @@ bool IsComparisonWithNullOp(const clang::BinaryOperator *expr);
 
 bool IsInMainFile(const clang::Decl *decl);
 
-bool IsCharPointerFieldFromLibc(const clang::ValueDecl *decl);
-
-bool IsCharArrayFieldFromLibc(const clang::ValueDecl *decl);
-
 bool IsUserDefinedDecl(const clang::Decl *decl);
 
 bool RefersToUserDefinedDecl(const clang::Expr *expr);
diff --git a/cpp2rust/converter/mapper.cpp b/cpp2rust/converter/mapper.cpp
index cc39e781..6be40f17 100644
--- a/cpp2rust/converter/mapper.cpp
+++ b/cpp2rust/converter/mapper.cpp
@@ -530,7 +530,14 @@ void addBuiltinTypes(Model model) {
   }
 
   // Char
-  add_builtin_rule(ctx_->CharTy, "u8");
+  switch (model) {
+  case Model::kUnsafe:
+    add_builtin_rule(ctx_->CharTy, "libc::c_char");
+    break;
+  case Model::kRefCount:
+    add_builtin_rule(ctx_->CharTy, "u8");
+    break;
+  }
   add_builtin_rule(ctx_->SignedCharTy, "i8");
   add_builtin_rule(ctx_->UnsignedCharTy, "u8");
 
diff --git a/cpp2rust/converter/models/converter_refcount.cpp b/cpp2rust/converter/models/converter_refcount.cpp
index 044bd580..2af0f071 100644
--- a/cpp2rust/converter/models/converter_refcount.cpp
+++ b/cpp2rust/converter/models/converter_refcount.cpp
@@ -211,7 +211,8 @@ std::string ConverterRefCount::BuildFnAdapter(
         closure += std::format("a{}.reinterpret_cast::<{}>()", i,
                                ConvertPointeeType(src_pty));
       } else if (src_pty->getPointeeType()->isCharType()) {
-        closure += std::format("a{}.reinterpret_cast::<u8>()", i);
+        closure += std::format("a{}.reinterpret_cast::<{}>()", i,
+                               ConvertPointeeType(src_pty));
       }
     } else {
       // UB: Incompatible types
@@ -1103,8 +1104,7 @@ bool ConverterRefCount::VisitStringLiteral(clang::StringLiteral *expr) {
                 ? arr_size - expr->getString().size()
                 : 0;
     }
-    StrCat(std::format("Box::<[u8]>::from(b{}.as_slice())",
-                       GetEscapedStringLiteral(expr, pad)));
+    StrCat(std::format("Box::from(*b{})", GetEscapedStringLiteral(expr, pad)));
     return false;
   }
   StrCat(std::format("b{}", GetEscapedStringLiteral(expr, 0)));
diff --git a/cpp2rust/converter/models/converter_refcount.h b/cpp2rust/converter/models/converter_refcount.h
index 7737a244..819fa4ff 100644
--- a/cpp2rust/converter/models/converter_refcount.h
+++ b/cpp2rust/converter/models/converter_refcount.h
@@ -32,6 +32,8 @@ class ConverterRefCount final : public Converter {
 
   bool EmitsReprCForRecords() const override { return false; }
 
+  const char *CharRustType() const override { return "u8"; }
+
   void ConvertOrdAndPartialOrdTraits(const clang::CXXRecordDecl *decl,
                                      const clang::FunctionDecl *op) override;
 
diff --git a/cpp2rust/cpp2rust.cpp b/cpp2rust/cpp2rust.cpp
index 0c791d09..ec3ac921 100644
--- a/cpp2rust/cpp2rust.cpp
+++ b/cpp2rust/cpp2rust.cpp
@@ -190,7 +190,7 @@ int main(int argc, char *argv[]) {
   file.close();
 
   // call rustfmt.
-  std::string rustfmt_command = "rustfmt " + RsFile;
+  std::string rustfmt_command = "rustfmt --edition 2024 " + RsFile;
   if (std::system(rustfmt_command.c_str()) != 0) {
     llvm::errs() << "ERROR: failed to run rustfmt\n";
     return EXIT_FAILURE;
diff --git a/libcc2rs/src/alloc.rs b/libcc2rs/src/alloc.rs
index 53112b2d..4c643188 100644
--- a/libcc2rs/src/alloc.rs
+++ b/libcc2rs/src/alloc.rs
@@ -32,6 +32,6 @@ pub unsafe fn calloc_unsafe(a0: usize, a1: usize) -> *mut libc::c_void {
 /// # Safety
 ///
 /// Same contract as C's `strdup`.
-pub unsafe fn strdup_unsafe(a0: *const u8) -> *mut u8 {
-    unsafe { libc::strdup(a0 as *const libc::c_char) as *mut u8 }
+pub unsafe fn strdup_unsafe(a0: *const libc::c_char) -> *mut libc::c_char {
+    unsafe { libc::strdup(a0) }
 }
diff --git a/rules/algorithm/tgt_unsafe.rs b/rules/algorithm/tgt_unsafe.rs
index 42bb36e2..101a2060 100644
--- a/rules/algorithm/tgt_unsafe.rs
+++ b/rules/algorithm/tgt_unsafe.rs
@@ -101,7 +101,11 @@ unsafe fn f12<T1: Clone>(a0: *mut T1, a1: *mut T1, a2: T1) {
     std::slice::from_raw_parts_mut(a0, count).fill(a2)
 }
 
-unsafe fn f13(a0: *const u8, a1: *const u8, a2: &mut ::std::fs::File) -> ::std::fs::File {
+unsafe fn f13(
+    a0: *const libc::c_char,
+    a1: *const libc::c_char,
+    a2: &mut ::std::fs::File,
+) -> ::std::fs::File {
     let __start = a0 as *const u8;
     let __end = a1 as *const u8;
     let __len = __end.offset_from(__start) as usize;
diff --git a/rules/arpa_inet/tgt_unsafe.rs b/rules/arpa_inet/tgt_unsafe.rs
index 3231d4b4..97115385 100644
--- a/rules/arpa_inet/tgt_unsafe.rs
+++ b/rules/arpa_inet/tgt_unsafe.rs
@@ -13,15 +13,25 @@ unsafe fn f3(a0: u16) -> u16 {
 unsafe fn f4(a0: u32) -> u32 {
     u32::to_be(a0)
 }
-unsafe fn f5(a0: i32, a1: *const u8, a2: *mut ::libc::c_void) -> i32 {
+unsafe fn f5(a0: i32, a1: *const libc::c_char, a2: *mut ::libc::c_void) -> i32 {
     unsafe extern "C" {
-        fn inet_pton(af: i32, src: *const u8, dst: *mut ::libc::c_void) -> i32;
+        fn inet_pton(af: i32, src: *const libc::c_char, dst: *mut ::libc::c_void) -> i32;
     }
     inet_pton(a0, a1, a2)
 }
-unsafe fn f6(a0: i32, a1: *const ::libc::c_void, a2: *mut u8, a3: u32) -> *const u8 {
+unsafe fn f6(
+    a0: i32,
+    a1: *const ::libc::c_void,
+    a2: *mut libc::c_char,
+    a3: u32,
+) -> *const libc::c_char {
     unsafe extern "C" {
-        fn inet_ntop(af: i32, src: *const ::libc::c_void, dst: *mut u8, size: u32) -> *const u8;
+        fn inet_ntop(
+            af: i32,
+            src: *const ::libc::c_void,
+            dst: *mut libc::c_char,
+            size: u32,
+        ) -> *const libc::c_char;
     }
     inet_ntop(a0, a1, a2, a3)
 }
diff --git a/rules/cstdlib/tgt_unsafe.rs b/rules/cstdlib/tgt_unsafe.rs
index 1aa1d113..5b983c43 100644
--- a/rules/cstdlib/tgt_unsafe.rs
+++ b/rules/cstdlib/tgt_unsafe.rs
@@ -21,12 +21,12 @@ unsafe fn f5(a0: usize, a1: usize) -> *mut ::libc::c_void {
     libcc2rs::calloc_unsafe(a0, a1)
 }
 
-unsafe fn f6(a0: *const u8) -> *mut u8 {
-    libc::getenv(a0 as *const i8) as *mut u8
+unsafe fn f6(a0: *const libc::c_char) -> *mut libc::c_char {
+    libc::getenv(a0)
 }
 
-unsafe fn f7(a0: *const u8, a1: *const u8, a2: i32) -> i32 {
-    libc::setenv(a0 as *const i8, a1 as *const i8, a2)
+unsafe fn f7(a0: *const libc::c_char, a1: *const libc::c_char, a2: i32) -> i32 {
+    libc::setenv(a0, a1, a2)
 }
 
 unsafe fn f8(
@@ -65,6 +65,6 @@ unsafe fn f9(
     )
 }
 
-unsafe fn f10(a0: *const u8, a1: *mut u8) -> *mut u8 {
-    libc::realpath(a0 as *const i8, a1 as *mut i8) as *mut u8
+unsafe fn f10(a0: *const libc::c_char, a1: *mut libc::c_char) -> *mut libc::c_char {
+    libc::realpath(a0, a1)
 }
diff --git a/rules/cstring/tgt_unsafe.rs b/rules/cstring/tgt_unsafe.rs
index 2113bc02..b44e6653 100644
--- a/rules/cstring/tgt_unsafe.rs
+++ b/rules/cstring/tgt_unsafe.rs
@@ -36,80 +36,80 @@ unsafe fn f4(a0: *mut u8, a1: *const u8, a2: usize) -> *mut u8 {
     a0
 }
 
-unsafe fn f5(a0: *const u8, a1: i32) -> *mut u8 {
-    libc::strchr(a0 as *const i8, a1) as *mut u8
+unsafe fn f5(a0: *const libc::c_char, a1: i32) -> *mut libc::c_char {
+    libc::strchr(a0, a1)
 }
 
-unsafe fn f6(a0: *const u8, a1: i32) -> *const u8 {
-    libc::strchr(a0 as *const i8, a1) as *const u8
+unsafe fn f6(a0: *const libc::c_char, a1: i32) -> *const libc::c_char {
+    (libc::strchr(a0, a1) as *const libc::c_char)
 }
 
-unsafe fn f7(a0: *const u8) -> usize {
-    libc::strlen(a0 as *const i8)
+unsafe fn f7(a0: *const libc::c_char) -> usize {
+    libc::strlen(a0)
 }
 
-unsafe fn f8(a0: *const u8, a1: *const u8) -> i32 {
-    libc::strcmp(a0 as *const i8, a1 as *const i8)
+unsafe fn f8(a0: *const libc::c_char, a1: *const libc::c_char) -> i32 {
+    libc::strcmp(a0, a1)
 }
 
-unsafe fn f9(a0: *const u8, a1: *const u8, a2: usize) -> i32 {
-    libc::strncmp(a0 as *const i8, a1 as *const i8, a2 as usize)
+unsafe fn f9(a0: *const libc::c_char, a1: *const libc::c_char, a2: usize) -> i32 {
+    libc::strncmp(a0, a1, a2 as usize)
 }
 
 unsafe fn f10(a0: *const u8, a1: i32, a2: usize) -> *mut ::libc::c_void {
     libc::memchr(a0 as *const ::libc::c_void, a1, a2 as usize)
 }
 
-unsafe fn f11(a0: *const u8, a1: i32) -> *mut u8 {
-    libc::strrchr(a0 as *const i8, a1) as *mut u8
+unsafe fn f11(a0: *const libc::c_char, a1: i32) -> *mut libc::c_char {
+    libc::strrchr(a0, a1)
 }
 
 unsafe fn f12(a0: *const u8, a1: i32, a2: usize) -> *const ::libc::c_void {
     libc::memchr(a0 as *const ::libc::c_void, a1, a2 as usize) as *const ::libc::c_void
 }
 
-unsafe fn f13(a0: *const u8, a1: i32) -> *const u8 {
-    libc::strrchr(a0 as *const i8, a1) as *const u8
+unsafe fn f13(a0: *const libc::c_char, a1: i32) -> *const libc::c_char {
+    (libc::strrchr(a0, a1) as *const libc::c_char)
 }
 
-unsafe fn f14(a0: *mut u8, a1: i32) -> *mut u8 {
-    libc::strrchr(a0 as *const i8, a1) as *mut u8
+unsafe fn f14(a0: *mut libc::c_char, a1: i32) -> *mut libc::c_char {
+    libc::strrchr(a0, a1)
 }
 
-unsafe fn f15(a0: *const u8) -> *mut u8 {
+unsafe fn f15(a0: *const libc::c_char) -> *mut libc::c_char {
     libcc2rs::strdup_unsafe(a0)
 }
 
-unsafe fn f16(a0: *const u8, a1: *const u8) -> usize {
-    libc::strcspn(a0 as *const i8, a1 as *const i8)
+unsafe fn f16(a0: *const libc::c_char, a1: *const libc::c_char) -> usize {
+    libc::strcspn(a0, a1)
 }
 
-unsafe fn f17(a0: *const u8, a1: *const u8) -> usize {
-    libc::strspn(a0 as *const i8, a1 as *const i8)
+unsafe fn f17(a0: *const libc::c_char, a1: *const libc::c_char) -> usize {
+    libc::strspn(a0, a1)
 }
 
-unsafe fn f18(a0: *const u8, a1: *const u8) -> *mut u8 {
-    libc::strstr(a0 as *const i8, a1 as *const i8) as *mut u8
+unsafe fn f18(a0: *const libc::c_char, a1: *const libc::c_char) -> *mut libc::c_char {
+    libc::strstr(a0, a1)
 }
 
-unsafe fn f19(a0: *const u8, a1: *const u8) -> *const u8 {
-    libc::strstr(a0 as *const i8, a1 as *const i8) as *const u8
+unsafe fn f19(a0: *const libc::c_char, a1: *const libc::c_char) -> *const libc::c_char {
+    (libc::strstr(a0, a1) as *const libc::c_char)
 }
 
-unsafe fn f20(a0: *mut u8, a1: *const u8) -> *mut u8 {
-    libc::strstr(a0 as *const i8, a1 as *const i8) as *mut u8
+unsafe fn f20(a0: *mut libc::c_char, a1: *const libc::c_char) -> *mut libc::c_char {
+    libc::strstr(a0, a1)
 }
 
-unsafe fn f21(a0: *const u8, a1: *const u8) -> *mut u8 {
-    libc::strpbrk(a0 as *const i8, a1 as *const i8) as *mut u8
+unsafe fn f21(a0: *const libc::c_char, a1: *const libc::c_char) -> *mut libc::c_char {
+    libc::strpbrk(a0, a1)
 }
 
-unsafe fn f22(a0: *const u8, a1: *const u8) -> *const u8 {
-    libc::strpbrk(a0 as *const i8, a1 as *const i8) as *const u8
+unsafe fn f22(a0: *const libc::c_char, a1: *const libc::c_char) -> *const libc::c_char {
+    (libc::strpbrk(a0, a1) as *const libc::c_char)
 }
 
-unsafe fn f23(a0: *mut u8, a1: *const u8) -> *mut u8 {
-    libc::strpbrk(a0 as *const i8, a1 as *const i8) as *mut u8
+unsafe fn f23(a0: *mut libc::c_char, a1: *const libc::c_char) -> *mut libc::c_char {
+    libc::strpbrk(a0, a1)
 }
 
 #[cfg(target_os = "linux")]
@@ -127,8 +127,8 @@ unsafe fn f26(a0: *mut u8, a1: i32, a2: usize) -> *mut ::libc::c_void {
     libc::memrchr(a0 as *const ::libc::c_void, a1, a2 as usize)
 }
 
-unsafe fn f27(a0: *const u8, a1: *const u8) -> i32 {
-    libc::strcasecmp(a0 as *const i8, a1 as *const i8)
+unsafe fn f27(a0: *const libc::c_char, a1: *const libc::c_char) -> i32 {
+    libc::strcasecmp(a0, a1)
 }
 
 // From the man page:
@@ -139,12 +139,12 @@ unsafe fn f27(a0: *const u8, a1: *const u8) -> i32 {
 //
 // So it's not 100% correct to always return a1. But the Rust libc version only returns int.
 #[cfg(target_os = "linux")]
-unsafe fn f28(a0: i32, a1: *mut u8, a2: usize) -> *mut u8 {
-    libc::strerror_r(a0, a1 as *mut i8, a2 as usize);
+unsafe fn f28(a0: i32, a1: *mut libc::c_char, a2: usize) -> *mut libc::c_char {
+    libc::strerror_r(a0, a1, a2 as usize);
     a1
 }
 
 #[cfg(target_os = "macos")]
-unsafe fn f28(a0: i32, a1: *mut u8, a2: usize) -> i32 {
-    libc::strerror_r(a0, a1 as *mut i8, a2 as usize)
+unsafe fn f28(a0: i32, a1: *mut libc::c_char, a2: usize) -> i32 {
+    libc::strerror_r(a0, a1, a2 as usize)
 }
diff --git a/rules/dirent/tgt_unsafe.rs b/rules/dirent/tgt_unsafe.rs
index de16e9e0..602fa429 100644
--- a/rules/dirent/tgt_unsafe.rs
+++ b/rules/dirent/tgt_unsafe.rs
@@ -5,8 +5,8 @@ fn t1() -> *mut ::libc::DIR {
     std::ptr::null_mut()
 }
 
-unsafe fn f1(a0: *const u8) -> *mut ::libc::DIR {
-    libc::opendir(a0 as *const i8)
+unsafe fn f1(a0: *const libc::c_char) -> *mut ::libc::DIR {
+    libc::opendir(a0)
 }
 
 unsafe fn f2(a0: *mut ::libc::DIR) -> *mut ::libc::dirent {
diff --git a/rules/fnmatch/tgt_unsafe.rs b/rules/fnmatch/tgt_unsafe.rs
index 9be3d0cd..89d3d181 100644
--- a/rules/fnmatch/tgt_unsafe.rs
+++ b/rules/fnmatch/tgt_unsafe.rs
@@ -1,6 +1,6 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-unsafe fn f1(a0: *const u8, a1: *const u8, a2: i32) -> i32 {
-    libc::fnmatch(a0 as *const i8, a1 as *const i8, a2)
+unsafe fn f1(a0: *const libc::c_char, a1: *const libc::c_char, a2: i32) -> i32 {
+    libc::fnmatch(a0, a1, a2)
 }
diff --git a/rules/fstream/tgt_unsafe.rs b/rules/fstream/tgt_unsafe.rs
index ce16e030..5e5a37da 100644
--- a/rules/fstream/tgt_unsafe.rs
+++ b/rules/fstream/tgt_unsafe.rs
@@ -13,13 +13,8 @@ fn t3() -> ::std::fs::File {
     ::std::fs::File::open("").unwrap()
 }
 
-unsafe fn f1(a0: *const u8) -> ::std::fs::File {
-    ::std::fs::File::create(
-        ::std::ffi::CStr::from_ptr(a0 as *const i8)
-            .to_str()
-            .unwrap(),
-    )
-    .unwrap()
+unsafe fn f1(a0: *const libc::c_char) -> ::std::fs::File {
+    ::std::fs::File::create(::std::ffi::CStr::from_ptr(a0).to_str().unwrap()).unwrap()
 }
 
 unsafe fn f2(a0: ::std::fs::File) -> ::std::fs::File {
@@ -31,13 +26,8 @@ unsafe fn f3(a0: &mut ::std::fs::File) -> &mut ::std::fs::File {
 unsafe fn f4(a0: ::std::fs::File) -> ::std::fs::File {
     a0
 }
-unsafe fn f5(a0: *const u8) -> ::std::fs::File {
-    ::std::fs::File::open(
-        ::std::ffi::CStr::from_ptr(a0 as *const i8)
-            .to_str()
-            .unwrap(),
-    )
-    .unwrap()
+unsafe fn f5(a0: *const libc::c_char) -> ::std::fs::File {
+    ::std::fs::File::open(::std::ffi::CStr::from_ptr(a0).to_str().unwrap()).unwrap()
 }
 
 unsafe fn f6(a0: ::std::fs::File) -> ::std::fs::File {
diff --git a/rules/locale/tgt_unsafe.rs b/rules/locale/tgt_unsafe.rs
index 53d2d1a3..13fec7ac 100644
--- a/rules/locale/tgt_unsafe.rs
+++ b/rules/locale/tgt_unsafe.rs
@@ -1,6 +1,6 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-unsafe fn f1(a0: i32, a1: *const u8) -> *mut u8 {
-    libc::setlocale(a0, a1 as *const i8) as *mut u8
+unsafe fn f1(a0: i32, a1: *const libc::c_char) -> *mut libc::c_char {
+    libc::setlocale(a0, a1)
 }
diff --git a/rules/net_if/tgt_unsafe.rs b/rules/net_if/tgt_unsafe.rs
index f87fdccb..5ae78787 100644
--- a/rules/net_if/tgt_unsafe.rs
+++ b/rules/net_if/tgt_unsafe.rs
@@ -1,6 +1,6 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-unsafe fn f1(a0: *const u8) -> u32 {
-    libc::if_nametoindex(a0 as *const i8)
+unsafe fn f1(a0: *const libc::c_char) -> u32 {
+    libc::if_nametoindex(a0)
 }
diff --git a/rules/netdb/tgt_unsafe.rs b/rules/netdb/tgt_unsafe.rs
index 6e40b3df..d1f74394 100644
--- a/rules/netdb/tgt_unsafe.rs
+++ b/rules/netdb/tgt_unsafe.rs
@@ -2,12 +2,12 @@
 // Distributed under the MIT license that can be found in the LICENSE file.
 
 unsafe fn f1(
-    a0: *const u8,
-    a1: *const u8,
+    a0: *const libc::c_char,
+    a1: *const libc::c_char,
     a2: *const ::libc::addrinfo,
     a3: *mut *mut ::libc::addrinfo,
 ) -> i32 {
-    libc::getaddrinfo(a0 as *const i8, a1 as *const i8, a2, a3)
+    libc::getaddrinfo(a0, a1, a2, a3)
 }
 
 unsafe fn f2(a0: *mut ::libc::addrinfo) {
diff --git a/rules/pwd/tgt_unsafe.rs b/rules/pwd/tgt_unsafe.rs
index 6f0bbc7b..d20596f9 100644
--- a/rules/pwd/tgt_unsafe.rs
+++ b/rules/pwd/tgt_unsafe.rs
@@ -8,9 +8,9 @@ unsafe fn f1(a0: u32) -> *mut ::libc::passwd {
 unsafe fn f2(
     a0: u32,
     a1: *mut ::libc::passwd,
-    a2: *mut u8,
+    a2: *mut libc::c_char,
     a3: usize,
     a4: *mut *mut ::libc::passwd,
 ) -> i32 {
-    libc::getpwuid_r(a0, a1, a2 as *mut i8, a3, a4)
+    libc::getpwuid_r(a0, a1, a2, a3, a4)
 }
diff --git a/rules/stat/tgt_unsafe.rs b/rules/stat/tgt_unsafe.rs
index 038bd70b..5d0f9703 100644
--- a/rules/stat/tgt_unsafe.rs
+++ b/rules/stat/tgt_unsafe.rs
@@ -1,14 +1,14 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-unsafe fn f1(a0: *const u8, a1: *mut ::libc::stat) -> i32 {
-    libc::stat(a0 as *const i8, a1)
+unsafe fn f1(a0: *const libc::c_char, a1: *mut ::libc::stat) -> i32 {
+    libc::stat(a0, a1)
 }
 
 unsafe fn f2(a0: i32, a1: *mut ::libc::stat) -> i32 {
     libc::fstat(a0, a1)
 }
 
-unsafe fn f3(a0: *const u8, a1: ::libc::mode_t) -> i32 {
-    libc::mkdir(a0 as *const i8, a1 as ::libc::mode_t)
+unsafe fn f3(a0: *const libc::c_char, a1: ::libc::mode_t) -> i32 {
+    libc::mkdir(a0, a1 as ::libc::mode_t)
 }
diff --git a/rules/stdio/tgt_unsafe.rs b/rules/stdio/tgt_unsafe.rs
index 6351056a..65a8117b 100644
--- a/rules/stdio/tgt_unsafe.rs
+++ b/rules/stdio/tgt_unsafe.rs
@@ -5,8 +5,8 @@ fn t1() -> *mut ::libc::FILE {
     std::ptr::null_mut()
 }
 
-unsafe fn f1(a0: *const u8, a1: *const u8) -> *mut ::libc::FILE {
-    libc::fopen(a0 as *const i8, a1 as *const i8)
+unsafe fn f1(a0: *const libc::c_char, a1: *const libc::c_char) -> *mut ::libc::FILE {
+    libc::fopen(a0, a1)
 }
 
 unsafe fn f2(a0: *mut ::libc::FILE) -> i32 {
@@ -49,12 +49,12 @@ unsafe fn f11(a0: i32, a1: *mut ::libc::FILE) -> i32 {
     libc::fputc(a0, a1)
 }
 
-unsafe fn f12(a0: *const u8, a1: *mut ::libc::FILE) -> i32 {
-    libc::fputs(a0 as *const i8, a1)
+unsafe fn f12(a0: *const libc::c_char, a1: *mut ::libc::FILE) -> i32 {
+    libc::fputs(a0, a1)
 }
 
-unsafe fn f13(a0: *const u8) -> i32 {
-    libc::puts(a0 as *const i8)
+unsafe fn f13(a0: *const libc::c_char) -> i32 {
+    libc::puts(a0)
 }
 
 unsafe fn f14(a0: *mut ::libc::FILE) -> i32 {
@@ -69,30 +69,34 @@ unsafe fn f16(a0: *mut ::libc::FILE) -> i32 {
     libc::feof(a0)
 }
 
-unsafe fn f17(a0: *mut u8, a1: i32, a2: *mut ::libc::FILE) -> *mut u8 {
-    libc::fgets(a0 as *mut i8, a1, a2) as *mut u8
+unsafe fn f17(a0: *mut libc::c_char, a1: i32, a2: *mut ::libc::FILE) -> *mut libc::c_char {
+    libc::fgets(a0, a1, a2)
 }
 
-unsafe fn f18(a0: *const u8, a1: *const u8, a2: *mut ::libc::FILE) -> *mut ::libc::FILE {
-    libc::freopen(a0 as *const i8, a1 as *const i8, a2)
+unsafe fn f18(
+    a0: *const libc::c_char,
+    a1: *const libc::c_char,
+    a2: *mut ::libc::FILE,
+) -> *mut ::libc::FILE {
+    libc::freopen(a0, a1, a2)
 }
 
 unsafe fn f19(a0: *mut ::libc::FILE, a1: i64, a2: i32) -> i32 {
     libc::fseeko(a0, a1 as ::libc::off_t, a2)
 }
 
-unsafe fn f20(a0: i32, a1: *const u8) -> *mut ::libc::FILE {
-    libc::fdopen(a0, a1 as *const i8)
+unsafe fn f20(a0: i32, a1: *const libc::c_char) -> *mut ::libc::FILE {
+    libc::fdopen(a0, a1)
 }
 
-unsafe fn f22(a0: *const i8, a1: *const i8) -> i32 {
-    libc::rename(a0 as *const i8, a1 as *const i8)
+unsafe fn f22(a0: *const libc::c_char, a1: *const libc::c_char) -> i32 {
+    libc::rename(a0, a1)
 }
 
 unsafe fn f23(a0: *mut ::libc::FILE) -> i32 {
     libc::fgetc(a0)
 }
 
-unsafe fn f24(a0: *mut ::libc::FILE, a1: *mut u8, a2: i32, a3: usize) -> i32 {
-    libc::setvbuf(a0, a1 as *mut i8, a2, a3)
+unsafe fn f24(a0: *mut ::libc::FILE, a1: *mut libc::c_char, a2: i32, a3: usize) -> i32 {
+    libc::setvbuf(a0, a1, a2, a3)
 }
diff --git a/rules/string/tgt_refcount.rs b/rules/string/tgt_refcount.rs
index cb725ff1..389e68fa 100644
--- a/rules/string/tgt_refcount.rs
+++ b/rules/string/tgt_refcount.rs
@@ -5,6 +5,10 @@ use libcc2rs::*;
 use std::cell::RefCell;
 use std::rc::Rc;
 
+fn t1() -> Vec<u8> {
+    Vec::new()
+}
+
 fn t2() -> Ptr<u8> {
     Ptr::null()
 }
@@ -121,3 +125,52 @@ fn f26(a0: Ptr<Vec<u8>>, a1: usize) -> Ptr<u8> {
         (a0.to_strong().as_pointer() as Ptr<u8>).offset(a1 as isize)
     }
 }
+
+fn f2(a0: Vec<u8>) -> usize {
+    (a0.len() - 1)
+}
+
+fn f8(a0: std::fs::File, a1: std::fs::File) -> Vec<u8> {
+    use std::io::Read;
+    let mut __bytes: Vec<u8> = Vec::new();
+    let mut __f = &a0;
+    __f.read_to_end(&mut __bytes)
+        .expect("couldn't read the file");
+    __bytes.push(0);
+    __bytes
+}
+
+fn f9(a0: usize, a1: u8) -> Vec<u8> {
+    vec![a1; (a0) as usize]
+        .iter()
+        .cloned()
+        .chain(std::iter::once(0))
+        .collect()
+}
+
+fn f13(a0: &mut Vec<u8>, a1: usize) {
+    a0.pop();
+    a0.resize((a1) as usize, 0);
+    a0.push(0)
+}
+
+fn f19(a0: Vec<u8>) -> usize {
+    (a0.len() - 1)
+}
+
+fn f22(a0: Vec<u8>) -> bool {
+    a0.len() <= 1
+}
+
+fn f23() -> Vec<u8> {
+    vec![0]
+}
+
+fn f24(a0: &mut Vec<u8>) {
+    a0.clear();
+    a0.push(0)
+}
+
+fn f25(a0: &mut Vec<u8>) {
+    a0.shrink_to_fit()
+}
diff --git a/rules/string/tgt_unsafe.rs b/rules/string/tgt_unsafe.rs
index 81b1fc07..b36e9d9b 100644
--- a/rules/string/tgt_unsafe.rs
+++ b/rules/string/tgt_unsafe.rs
@@ -1,23 +1,23 @@
 // Copyright (c) 2022-present INESC-ID.
 // Distributed under the MIT license that can be found in the LICENSE file.
 
-fn t1() -> Vec<u8> {
+fn t1() -> Vec<libc::c_char> {
     Vec::new()
 }
 
-fn t2() -> *mut u8 {
+fn t2() -> *mut libc::c_char {
     ::std::ptr::null_mut()
 }
 
-unsafe fn f1(a0: Vec<u8>, a1: usize, a2: usize) -> Vec<u8> {
+unsafe fn f1(a0: Vec<libc::c_char>, a1: usize, a2: usize) -> Vec<libc::c_char> {
     let mut __tmp1 = a0[(a1) as usize..::std::cmp::min((a1 + a2) as usize, a0.len() - 1)].to_vec();
     __tmp1.push(0);
     __tmp1
 }
-unsafe fn f2(a0: Vec<u8>) -> usize {
+unsafe fn f2(a0: Vec<libc::c_char>) -> usize {
     (a0.len() - 1)
 }
-unsafe fn f3(a0: Vec<u8>, a1: *const u8) -> Vec<u8> {
+unsafe fn f3(a0: Vec<libc::c_char>, a1: *const libc::c_char) -> Vec<libc::c_char> {
     let mut __tmp2 = a0.clone();
     __tmp2.pop();
     let __from = a1;
@@ -28,20 +28,20 @@ unsafe fn f3(a0: Vec<u8>, a1: *const u8) -> Vec<u8> {
     __tmp2.push(0);
     __tmp2
 }
-unsafe fn f4(a0: &mut Vec<u8>, a1: *mut u8, a2: usize) {
+unsafe fn f4(a0: &mut Vec<libc::c_char>, a1: *mut libc::c_char, a2: usize) {
     a0.splice(a0.len().saturating_sub(1)..a0.len(), {
         let mut v = ::std::slice::from_raw_parts(a1, a2 as usize).to_vec();
         v.push(0);
         v
     });
 }
-unsafe fn f5(a0: Vec<u8>) -> *const u8 {
+unsafe fn f5(a0: Vec<libc::c_char>) -> *const libc::c_char {
     a0.as_ptr()
 }
-unsafe fn f6(a0: &mut Vec<u8>) -> *const u8 {
+unsafe fn f6(a0: &mut Vec<libc::c_char>) -> *const libc::c_char {
     a0.as_mut_ptr()
 }
-unsafe fn f7(a0: *const u8, a1: usize) -> Vec<u8> {
+unsafe fn f7(a0: *const libc::c_char, a1: usize) -> Vec<libc::c_char> {
     std::slice::from_raw_parts(a0, a1 as usize)
         .to_vec()
         .iter()
@@ -52,48 +52,56 @@ unsafe fn f7(a0: *const u8, a1: usize) -> Vec<u8> {
 // TODO: this does not care for a1
 use std::io::Read;
 
-unsafe fn f8(a0: std::fs::File, a1: std::fs::File) -> Vec<u8> {
-    let mut __buf: Vec<u8> = Vec::new();
+unsafe fn f8(a0: std::fs::File, a1: std::fs::File) -> Vec<libc::c_char> {
+    let mut __bytes: Vec<u8> = Vec::new();
     let mut __f = &a0;
-    __f.read_to_end(&mut __buf).expect("couldn't read the file");
+    __f.read_to_end(&mut __bytes)
+        .expect("couldn't read the file");
+    let mut __buf: Vec<libc::c_char> = __bytes.iter().map(|&b| b as libc::c_char).collect();
     __buf.push(0);
     __buf
 }
 
-unsafe fn f9(a0: usize, a1: u8) -> Vec<u8> {
+unsafe fn f9(a0: usize, a1: libc::c_char) -> Vec<libc::c_char> {
     vec![a1; (a0) as usize]
         .iter()
         .cloned()
         .chain(std::iter::once(0))
         .collect()
 }
-unsafe fn f10(a0: *const u8) -> Vec<u8> {
+unsafe fn f10(a0: *const libc::c_char) -> Vec<libc::c_char> {
     let s = a0;
     std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
 }
-unsafe fn f11(a0: Vec<u8>) -> *const u8 {
+unsafe fn f11(a0: Vec<libc::c_char>) -> *const libc::c_char {
     a0.as_ptr()
 }
-unsafe fn f12(a0: &mut Vec<u8>) -> *mut u8 {
+unsafe fn f12(a0: &mut Vec<libc::c_char>) -> *mut libc::c_char {
     a0.as_mut_ptr()
 }
-unsafe fn f13(a0: &mut Vec<u8>, a1: usize) {
+unsafe fn f13(a0: &mut Vec<libc::c_char>, a1: usize) {
     a0.pop();
     a0.resize((a1) as usize, 0);
     a0.push(0)
 }
-unsafe fn f14(a0: &mut Vec<u8>, a1: usize, a2: usize, a3: *const u8, a4: usize) {
+unsafe fn f14(
+    a0: &mut Vec<libc::c_char>,
+    a1: usize,
+    a2: usize,
+    a3: *const libc::c_char,
+    a4: usize,
+) {
     a0.splice(
         a1 as usize..a1 as usize + a2 as usize,
         ::std::slice::from_raw_parts(a3, a4 as usize).to_vec(),
     );
 }
-unsafe fn f15(a0: &mut Vec<u8>) -> *mut u8 {
+unsafe fn f15(a0: &mut Vec<libc::c_char>) -> *mut libc::c_char {
     a0.as_mut_ptr().add(a0.len() - 1)
 }
-unsafe fn f16(a0: Vec<u8>, a1: *const u8) -> usize {
+unsafe fn f16(a0: Vec<libc::c_char>, a1: *const libc::c_char) -> usize {
     match a0.iter().rposition(|&c| {
-        ::std::ffi::CStr::from_ptr(a1 as *const i8)
+        ::std::ffi::CStr::from_ptr(a1)
             .to_str()
             .unwrap()
             .contains(c as u8 as char)
@@ -102,7 +110,7 @@ unsafe fn f16(a0: Vec<u8>, a1: *const u8) -> usize {
         None => usize::MAX,
     }
 }
-unsafe fn f17(a0: Vec<u8>, a1: *const u8) -> Vec<u8> {
+unsafe fn f17(a0: Vec<libc::c_char>, a1: *const libc::c_char) -> Vec<libc::c_char> {
     let mut __tmp2 = a0.clone();
     __tmp2.pop();
     let __from = a1;
@@ -113,43 +121,43 @@ unsafe fn f17(a0: Vec<u8>, a1: *const u8) -> Vec<u8> {
     __tmp2.push(0);
     __tmp2
 }
-unsafe fn f18(a0: Vec<u8>, a1: *const u8) -> bool {
+unsafe fn f18(a0: Vec<libc::c_char>, a1: *const libc::c_char) -> bool {
     a0 == {
         let s = a1;
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     }
 }
-unsafe fn f19(a0: Vec<u8>) -> usize {
+unsafe fn f19(a0: Vec<libc::c_char>) -> usize {
     (a0.len() - 1)
 }
-unsafe fn f20(a0: *mut u8, a1: usize) -> *mut u8 {
+unsafe fn f20(a0: *mut libc::c_char, a1: usize) -> *mut libc::c_char {
     a0.add(a1 as usize)
 }
-unsafe fn f21(a0: &mut Vec<u8>, a1: usize, a2: u8) {
+unsafe fn f21(a0: &mut Vec<libc::c_char>, a1: usize, a2: libc::c_char) {
     a0.splice(
         a0.len() - 1..a0.len() - 1,
         ::std::vec::from_elem(a2, a1 as usize),
     );
 }
 
-unsafe fn f22(a0: Vec<u8>) -> bool {
+unsafe fn f22(a0: Vec<libc::c_char>) -> bool {
     a0.len() <= 1
 }
 
-unsafe fn f23() -> Vec<u8> {
+unsafe fn f23() -> Vec<libc::c_char> {
     vec![0]
 }
 
-unsafe fn f24(a0: &mut Vec<u8>) {
+unsafe fn f24(a0: &mut Vec<libc::c_char>) {
     a0.clear();
     a0.push(0)
 }
 
-unsafe fn f25(a0: &mut Vec<u8>) {
+unsafe fn f25(a0: &mut Vec<libc::c_char>) {
     a0.shrink_to_fit()
 }
 
-unsafe fn f26(a0: &mut Vec<u8>, a1: usize) -> *mut u8 {
+unsafe fn f26(a0: &mut Vec<libc::c_char>, a1: usize) -> *mut libc::c_char {
     if a1 as usize >= a0.len() - 1 {
         panic!("out of bounds access")
     } else {
diff --git a/rules/time/tgt_unsafe.rs b/rules/time/tgt_unsafe.rs
index 0ba774cf..add3a6a0 100644
--- a/rules/time/tgt_unsafe.rs
+++ b/rules/time/tgt_unsafe.rs
@@ -17,12 +17,17 @@ unsafe fn f5(a0: *const ::libc::time_t, a1: *mut ::libc::tm) -> *mut ::libc::tm
     libc::localtime_r(a0, a1)
 }
 
-unsafe fn f6(a0: *mut u8, a1: usize, a2: *const u8, a3: *const ::libc::tm) -> usize {
-    libc::strftime(a0 as *mut i8, a1, a2 as *const i8, a3)
+unsafe fn f6(
+    a0: *mut libc::c_char,
+    a1: usize,
+    a2: *const libc::c_char,
+    a3: *const ::libc::tm,
+) -> usize {
+    libc::strftime(a0, a1, a2, a3)
 }
 
-unsafe fn f7(a0: *const u8, a1: *const ::libc::timeval) -> i32 {
-    libc::utimes(a0 as *const i8, a1)
+unsafe fn f7(a0: *const libc::c_char, a1: *const ::libc::timeval) -> i32 {
+    libc::utimes(a0, a1)
 }
 
 #[cfg(target_os = "linux")]
diff --git a/rules/unistd/tgt_unsafe.rs b/rules/unistd/tgt_unsafe.rs
index 7c9251b9..51b21d01 100644
--- a/rules/unistd/tgt_unsafe.rs
+++ b/rules/unistd/tgt_unsafe.rs
@@ -13,8 +13,8 @@ unsafe fn f3(a0: i32, a1: *mut ::libc::c_void, a2: usize) -> isize {
     libc::read(a0, a1, a2)
 }
 
-unsafe fn f4(a0: *const u8) -> i32 {
-    libc::unlink(a0 as *const i8)
+unsafe fn f4(a0: *const libc::c_char) -> i32 {
+    libc::unlink(a0)
 }
 
 unsafe fn f5(a0: *mut i32) -> i32 {
@@ -33,14 +33,14 @@ unsafe fn f8() -> u32 {
     libc::geteuid()
 }
 
-unsafe fn f9(a0: *mut u8, a1: usize) -> i32 {
-    libc::gethostname(a0 as *mut i8, a1)
+unsafe fn f9(a0: *mut libc::c_char, a1: usize) -> i32 {
+    libc::gethostname(a0, a1)
 }
 
 unsafe fn f10(a0: i32, a1: *const ::libc::c_void, a2: usize) -> isize {
     libc::write(a0, a1, a2)
 }
 
-unsafe fn f11(a0: *const u8) -> i32 {
-    libc::rmdir(a0 as *const i8)
+unsafe fn f11(a0: *const libc::c_char) -> i32 {
+    libc::rmdir(a0)
 }
diff --git a/rules/xattr/tgt_unsafe.rs b/rules/xattr/tgt_unsafe.rs
index b0bfda90..41b2022f 100644
--- a/rules/xattr/tgt_unsafe.rs
+++ b/rules/xattr/tgt_unsafe.rs
@@ -2,6 +2,12 @@
 // Distributed under the MIT license that can be found in the LICENSE file.
 
 #[cfg(target_os = "linux")]
-unsafe fn f1(a0: i32, a1: *const u8, a2: *const ::libc::c_void, a3: usize, a4: i32) -> i32 {
-    libc::fsetxattr(a0, a1 as *const i8, a2, a3, a4)
+unsafe fn f1(
+    a0: i32,
+    a1: *const libc::c_char,
+    a2: *const ::libc::c_void,
+    a3: usize,
+    a4: i32,
+) -> i32 {
+    libc::fsetxattr(a0, a1, a2, a3, a4)
 }
diff --git a/tests/ub/out/unsafe/ub21.rs b/tests/ub/out/unsafe/ub21.rs
index dcc51d86..ca595328 100644
--- a/tests/ub/out/unsafe/ub21.rs
+++ b/tests/ub/out/unsafe/ub21.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn strlen_0(mut s: *const u8) -> usize {
+pub unsafe fn strlen_0(mut s: *const libc::c_char) -> usize {
     let mut count: usize = 0_usize;
     'loop_: while ((*s.postfix_inc()) != 0) {
         count.prefix_inc();
@@ -19,6 +19,10 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let s: [u8; 3] = [('s' as u8), ('t' as u8), ('r' as u8)];
+    let s: [libc::c_char; 3] = [
+        ('s' as libc::c_char),
+        ('t' as libc::c_char),
+        ('r' as libc::c_char),
+    ];
     return ((unsafe { strlen_0(s.as_ptr()) }) as i32);
 }
diff --git a/tests/ub/out/unsafe/ub7.rs b/tests/ub/out/unsafe/ub7.rs
index cffacfe6..fbe355d9 100644
--- a/tests/ub/out/unsafe/ub7.rs
+++ b/tests/ub/out/unsafe/ub7.rs
@@ -6,12 +6,13 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn strlen_0(mut s: *const u8) -> usize {
-    let mut begin: *const u8 = s;
+pub unsafe fn strlen_0(mut s: *const libc::c_char) -> usize {
+    let mut begin: *const libc::c_char = s;
     'loop_: while ((*s) != 0) {
         s.prefix_inc();
     }
-    return ((((s as usize - begin as usize) / ::std::mem::size_of::<u8>()) as i64) as usize);
+    return ((((s as usize - begin as usize) / ::std::mem::size_of::<libc::c_char>()) as i64)
+        as usize);
 }
 pub fn main() {
     unsafe {
@@ -19,13 +20,13 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let s: [u8; 6] = [
-        ('s' as u8),
-        ('t' as u8),
-        ('r' as u8),
-        ('i' as u8),
-        ('n' as u8),
-        ('g' as u8),
+    let s: [libc::c_char; 6] = [
+        ('s' as libc::c_char),
+        ('t' as libc::c_char),
+        ('r' as libc::c_char),
+        ('i' as libc::c_char),
+        ('n' as libc::c_char),
+        ('g' as libc::c_char),
     ];
-    return ((unsafe { strlen_0((&s[(0) as usize] as *const u8)) }) as i32);
+    return ((unsafe { strlen_0((&s[(0) as usize] as *const libc::c_char)) }) as i32);
 }
diff --git a/tests/unit/out/refcount/char_printing.rs b/tests/unit/out/refcount/char_printing.rs
index 88c0c9bd..94842479 100644
--- a/tests/unit/out/refcount/char_printing.rs
+++ b/tests/unit/out/refcount/char_printing.rs
@@ -21,10 +21,14 @@ fn main_0() -> i32 {
     write!(libcc2rs::cout(), "{:} a", (*i.borrow()),);
     libcc2rs::cout().write_all(
         &([
-            (&[((vec_.as_pointer() as Ptr<u8>).offset(0_usize).read())] as &[u8]),
-            (&[((vec_.as_pointer() as Ptr<u8>).offset(1_usize).read())] as &[u8]),
-            (&[('o' as u8)] as &[u8]),
-            (&(*str.borrow())[..(*str.borrow()).len() - 1] as &[u8]),
+            (&[((vec_.as_pointer() as Ptr<u8>).offset(0_usize).read()) as u8] as &[u8]),
+            (&[((vec_.as_pointer() as Ptr<u8>).offset(1_usize).read()) as u8] as &[u8]),
+            (&[('o' as u8) as u8] as &[u8]),
+            (&(*str.borrow())
+                .iter()
+                .take((*str.borrow()).len() - 1)
+                .map(|&c| c as u8)
+                .collect::<Vec<u8>>()[..] as &[u8]),
             (&[b'\n'] as &[u8]),
         ]
         .concat()),
@@ -33,7 +37,7 @@ fn main_0() -> i32 {
     libcc2rs::cout().write_all(
         &([
             (b" a\xc3\xa7ordas?" as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
+            (&[('\n' as u8) as u8] as &[u8]),
             (b"Sim, 0x" as &[u8]),
         ]
         .concat()),
@@ -42,10 +46,10 @@ fn main_0() -> i32 {
     write!(libcc2rs::cout(), "Hello, World!\n",);
     libcc2rs::cout().write_all(
         &([
-            (&[((vec_.as_pointer() as Ptr<u8>).offset(0_usize).read())] as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
-            (&[((vec_.as_pointer() as Ptr<u8>).offset(1_usize).read())] as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
+            (&[((vec_.as_pointer() as Ptr<u8>).offset(0_usize).read()) as u8] as &[u8]),
+            (&[('\n' as u8) as u8] as &[u8]),
+            (&[((vec_.as_pointer() as Ptr<u8>).offset(1_usize).read()) as u8] as &[u8]),
+            (&[('\n' as u8) as u8] as &[u8]),
         ]
         .concat()),
     );
diff --git a/tests/unit/out/refcount/char_printing_cerr.rs b/tests/unit/out/refcount/char_printing_cerr.rs
index d1f9fa88..7453502a 100644
--- a/tests/unit/out/refcount/char_printing_cerr.rs
+++ b/tests/unit/out/refcount/char_printing_cerr.rs
@@ -21,10 +21,14 @@ fn main_0() -> i32 {
     write!(libcc2rs::cerr(), "{:} a", (*i.borrow()),);
     libcc2rs::cerr().write_all(
         &([
-            (&[((vec_.as_pointer() as Ptr<u8>).offset(0_usize).read())] as &[u8]),
-            (&[((vec_.as_pointer() as Ptr<u8>).offset(1_usize).read())] as &[u8]),
-            (&[('o' as u8)] as &[u8]),
-            (&(*str.borrow())[..(*str.borrow()).len() - 1] as &[u8]),
+            (&[((vec_.as_pointer() as Ptr<u8>).offset(0_usize).read()) as u8] as &[u8]),
+            (&[((vec_.as_pointer() as Ptr<u8>).offset(1_usize).read()) as u8] as &[u8]),
+            (&[('o' as u8) as u8] as &[u8]),
+            (&(*str.borrow())
+                .iter()
+                .take((*str.borrow()).len() - 1)
+                .map(|&c| c as u8)
+                .collect::<Vec<u8>>()[..] as &[u8]),
             (&[b'\n'] as &[u8]),
         ]
         .concat()),
@@ -33,7 +37,7 @@ fn main_0() -> i32 {
     libcc2rs::cerr().write_all(
         &([
             (b" a\xc3\xa7ordas?" as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
+            (&[('\n' as u8) as u8] as &[u8]),
             (b"Sim, 0x" as &[u8]),
         ]
         .concat()),
@@ -42,10 +46,10 @@ fn main_0() -> i32 {
     write!(libcc2rs::cerr(), "Hello, World!\n",);
     libcc2rs::cerr().write_all(
         &([
-            (&[((vec_.as_pointer() as Ptr<u8>).offset(0_usize).read())] as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
-            (&[((vec_.as_pointer() as Ptr<u8>).offset(1_usize).read())] as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
+            (&[((vec_.as_pointer() as Ptr<u8>).offset(0_usize).read()) as u8] as &[u8]),
+            (&[('\n' as u8) as u8] as &[u8]),
+            (&[((vec_.as_pointer() as Ptr<u8>).offset(1_usize).read()) as u8] as &[u8]),
+            (&[('\n' as u8) as u8] as &[u8]),
         ]
         .concat()),
     );
diff --git a/tests/unit/out/refcount/doubly_linked_list.rs b/tests/unit/out/refcount/doubly_linked_list.rs
index e584674d..a79aebd6 100644
--- a/tests/unit/out/refcount/doubly_linked_list.rs
+++ b/tests/unit/out/refcount/doubly_linked_list.rs
@@ -286,12 +286,14 @@ fn main_0() -> i32 {
         .borrow())
             == 4)
     );
-    assert!((*(*({ FindBack_1((*tail.borrow()).clone(), 4,) })
-        .upgrade()
-        .deref())
-    .prev
-    .borrow())
-    .is_null());
+    assert!(
+        (*(*({ FindBack_1((*tail.borrow()).clone(), 4,) })
+            .upgrade()
+            .deref())
+        .prev
+        .borrow())
+        .is_null()
+    );
     assert!(
         ((*(*(*(*({ Find_0((*head.borrow()).clone(), 0,) }).upgrade().deref())
             .next
diff --git a/tests/unit/out/refcount/push_emplace_back.rs b/tests/unit/out/refcount/push_emplace_back.rs
index 3166473c..07e74001 100644
--- a/tests/unit/out/refcount/push_emplace_back.rs
+++ b/tests/unit/out/refcount/push_emplace_back.rs
@@ -185,14 +185,16 @@ fn main_0() -> i32 {
     let vecs: Value<Vec<Value<Vec<u8>>>> = Rc::new(RefCell::new(Vec::new()));
     ({ push_param_0((vecs.as_pointer())) });
     assert!(((*vecs.borrow()).len() == 1_usize));
-    assert!((*((vecs.as_pointer() as Ptr<Value<Vec<u8>>>)
-        .offset(0_usize)
-        .upgrade()
-        .deref()
-        .as_pointer() as Ptr<Vec<u8>>)
-        .upgrade()
-        .deref())
-    .is_empty());
+    assert!(
+        (*((vecs.as_pointer() as Ptr<Value<Vec<u8>>>)
+            .offset(0_usize)
+            .upgrade()
+            .deref()
+            .as_pointer() as Ptr<Vec<u8>>)
+            .upgrade()
+            .deref())
+        .is_empty()
+    );
     let jpg: Value<JPEGData> = Rc::new(RefCell::new(<JPEGData>::default()));
     ({ push_local_from_field_1((jpg.as_pointer()), true) });
     assert!(((*(*jpg.borrow()).com_data.borrow()).len() == 1_usize));
diff --git a/tests/unit/out/refcount/stdcopy_ostream.rs b/tests/unit/out/refcount/stdcopy_ostream.rs
index 972d3167..abb70823 100644
--- a/tests/unit/out/refcount/stdcopy_ostream.rs
+++ b/tests/unit/out/refcount/stdcopy_ostream.rs
@@ -16,9 +16,7 @@ fn main_0() -> i32 {
             .chain(std::iter::once(0))
             .collect::<Vec<u8>>(),
     ));
-    let file: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::<[u8]>::from(
-        b"test_stdcopy_ostream.txt\0".as_slice(),
-    )));
+    let file: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"test_stdcopy_ostream.txt\0")));
     let ofs: Value<::std::fs::File> = Rc::new(RefCell::new(
         ::std::fs::File::create((file.as_pointer() as Ptr<u8>).to_string())
             .expect("Failed to open file"),
@@ -31,6 +29,6 @@ fn main_0() -> i32 {
         );
         (*ofs.borrow_mut()).try_clone().unwrap()
     };
-    libc::unlink((file.as_pointer() as Ptr<u8>) as *const i8);
+    libc::unlink((file.as_pointer() as Ptr<u8>));
     return 0;
 }
diff --git a/tests/unit/out/refcount/string.rs b/tests/unit/out/refcount/string.rs
index b91b033f..65dd3f2a 100644
--- a/tests/unit/out/refcount/string.rs
+++ b/tests/unit/out/refcount/string.rs
@@ -33,11 +33,13 @@ fn main_0() -> i32 {
     assert!(
         ((((s1.as_pointer() as Ptr<u8>).offset(4_usize).read()) as i32) == (('o' as u8) as i32))
     );
-    assert!((*s1.borrow())
-        .iter()
-        .copied()
-        .take((*s1.borrow()).len().saturating_sub(1))
-        .eq(Ptr::from_string_literal(b"hello").to_c_string_iterator()));
+    assert!(
+        (*s1.borrow())
+            .iter()
+            .copied()
+            .take((*s1.borrow()).len().saturating_sub(1))
+            .eq(Ptr::from_string_literal(b"hello").to_c_string_iterator())
+    );
     let p1: Value<Ptr<u8>> = Rc::new(RefCell::new((s1.as_pointer() as Ptr<u8>)));
     assert!(((((*p1.borrow()).offset((0) as isize).read()) as i32) == (('h' as u8) as i32)));
     assert!(((((*p1.borrow()).offset((1) as isize).read()) as i32) == (('e' as u8) as i32)));
@@ -194,11 +196,13 @@ fn main_0() -> i32 {
         ((((string.as_pointer() as Ptr<u8>).offset(2_usize).read()) as i32)
             == (('r' as u8) as i32))
     );
-    assert!((*string.borrow())
-        .iter()
-        .copied()
-        .take((*string.borrow()).len().saturating_sub(1))
-        .eq(Ptr::from_string_literal(b"bar").to_c_string_iterator()));
+    assert!(
+        (*string.borrow())
+            .iter()
+            .copied()
+            .take((*string.borrow()).len().saturating_sub(1))
+            .eq(Ptr::from_string_literal(b"bar").to_c_string_iterator())
+    );
     {
         (*string.borrow_mut()).pop();
         (*string.borrow_mut()).resize((3_usize) as usize, 0);
@@ -217,11 +221,13 @@ fn main_0() -> i32 {
         ((((string.as_pointer() as Ptr<u8>).offset(2_usize).read()) as i32)
             == (('r' as u8) as i32))
     );
-    assert!((*string.borrow())
-        .iter()
-        .copied()
-        .take((*string.borrow()).len().saturating_sub(1))
-        .eq(Ptr::from_string_literal(b"bar").to_c_string_iterator()));
+    assert!(
+        (*string.borrow())
+            .iter()
+            .copied()
+            .take((*string.borrow()).len().saturating_sub(1))
+            .eq(Ptr::from_string_literal(b"bar").to_c_string_iterator())
+    );
     {
         (*string.borrow_mut()).pop();
         (*string.borrow_mut()).resize((5_usize) as usize, 0);
diff --git a/tests/unit/out/refcount/string2.rs b/tests/unit/out/refcount/string2.rs
index cb27c8d2..d89e5ea0 100644
--- a/tests/unit/out/refcount/string2.rs
+++ b/tests/unit/out/refcount/string2.rs
@@ -23,10 +23,12 @@ fn main_0() -> i32 {
         (arr.as_pointer() as Ptr<u8>).offset((1) as isize),
     ));
     assert!(((((*p.borrow()).read()) as i32) == (('b' as u8) as i32)));
-    assert!((*arr.borrow())
-        .iter()
-        .copied()
-        .take((*arr.borrow()).len().saturating_sub(1))
-        .eq(Ptr::from_string_literal(b"fbo").to_c_string_iterator()));
+    assert!(
+        (*arr.borrow())
+            .iter()
+            .copied()
+            .take((*arr.borrow()).len().saturating_sub(1))
+            .eq(Ptr::from_string_literal(b"fbo").to_c_string_iterator())
+    );
     return 0;
 }
diff --git a/tests/unit/out/refcount/string_literals.rs b/tests/unit/out/refcount/string_literals.rs
index b705c1a4..d57498a6 100644
--- a/tests/unit/out/refcount/string_literals.rs
+++ b/tests/unit/out/refcount/string_literals.rs
@@ -23,10 +23,8 @@ fn main_0() -> i32 {
     ])));
     let immutable_string: Value<Ptr<u8>> =
         Rc::new(RefCell::new(Ptr::from_string_literal(b"hello")));
-    let mutable_string_arr: Value<Box<[u8]>> =
-        Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
-    let immutable_string_arr: Value<Box<[u8]>> =
-        Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
+    let mutable_string_arr: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"papanasi\0")));
+    let immutable_string_arr: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"papanasi\0")));
     let immutable_empty: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"")));
     let mutable_empty_arr: Value<Box<[u8]>> =
         Rc::new(RefCell::new(vec![0u8; 1].into_boxed_slice()));
@@ -39,9 +37,8 @@ fn main_0() -> i32 {
     ({ foo_const_1(Ptr::from_string_literal(b"")) });
     ({ foo_const_1((*immutable_empty.borrow()).clone()) });
     ({ foo_const_1((immutable_empty_arr.as_pointer() as Ptr<u8>)) });
-    let inited_through_init_list: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::<[u8]>::from(
-        b"papanasi cu smantana\0".as_slice(),
-    )));
+    let inited_through_init_list: Value<Box<[u8]>> =
+        Rc::new(RefCell::new(Box::from(*b"papanasi cu smantana\0")));
     ({ foo_const_1((inited_through_init_list.as_pointer() as Ptr<u8>)) });
     return 0;
 }
diff --git a/tests/unit/out/refcount/string_literals_c.rs b/tests/unit/out/refcount/string_literals_c.rs
index 6b05b0f7..bdac6f4e 100644
--- a/tests/unit/out/refcount/string_literals_c.rs
+++ b/tests/unit/out/refcount/string_literals_c.rs
@@ -29,10 +29,8 @@ fn main_0() -> i32 {
     let mutable_string: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"hello")));
     let immutable_string: Value<Ptr<u8>> =
         Rc::new(RefCell::new(Ptr::from_string_literal(b"hello")));
-    let mutable_string_arr: Value<Box<[u8]>> =
-        Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
-    let immutable_string_arr: Value<Box<[u8]>> =
-        Rc::new(RefCell::new(Box::<[u8]>::from(b"papanasi\0".as_slice())));
+    let mutable_string_arr: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"papanasi\0")));
+    let immutable_string_arr: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"papanasi\0")));
     let mutable_empty: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"")));
     let immutable_empty: Value<Ptr<u8>> = Rc::new(RefCell::new(Ptr::from_string_literal(b"")));
     let mutable_empty_arr: Value<Box<[u8]>> =
@@ -52,9 +50,8 @@ fn main_0() -> i32 {
     ({ foo_const_1((*immutable_empty.borrow()).clone()) });
     ({ foo_const_1((mutable_empty_arr.as_pointer() as Ptr<u8>)) });
     ({ foo_const_1((immutable_empty_arr.as_pointer() as Ptr<u8>)) });
-    let inited_through_init_list: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::<[u8]>::from(
-        b"papanasi cu smantana\0".as_slice(),
-    )));
+    let inited_through_init_list: Value<Box<[u8]>> =
+        Rc::new(RefCell::new(Box::from(*b"papanasi cu smantana\0")));
     ({ foo_const_1((inited_through_init_list.as_pointer() as Ptr<u8>)) });
     return 0;
 }
diff --git a/tests/unit/out/refcount/string_literals_concat.rs b/tests/unit/out/refcount/string_literals_concat.rs
index f9a457c2..07056ef6 100644
--- a/tests/unit/out/refcount/string_literals_concat.rs
+++ b/tests/unit/out/refcount/string_literals_concat.rs
@@ -16,7 +16,7 @@ fn main_0() -> i32 {
     assert!(((((*joined.borrow()).offset((0) as isize).read()) as i32) == (('a' as u8) as i32)));
     assert!(((((*joined.borrow()).offset((5) as isize).read()) as i32) == (('\n' as u8) as i32)));
     assert!(((((*joined.borrow()).offset((6) as isize).read()) as i32) == (('b' as u8) as i32)));
-    let arr: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::<[u8]>::from(b"foobar\0".as_slice())));
+    let arr: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"foobar\0")));
     assert!((((*arr.borrow())[(0) as usize] as i32) == (('f' as u8) as i32)));
     assert!((((*arr.borrow())[(3) as usize] as i32) == (('b' as u8) as i32)));
     assert!((((*arr.borrow())[(5) as usize] as i32) == (('r' as u8) as i32)));
diff --git a/tests/unit/out/refcount/string_literals_concat_c.rs b/tests/unit/out/refcount/string_literals_concat_c.rs
index 7852a135..5fa3aa27 100644
--- a/tests/unit/out/refcount/string_literals_concat_c.rs
+++ b/tests/unit/out/refcount/string_literals_concat_c.rs
@@ -10,7 +10,7 @@ pub fn main() {
     std::process::exit(main_0());
 }
 fn main_0() -> i32 {
-    let arr: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::<[u8]>::from(b"foobar\0".as_slice())));
+    let arr: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"foobar\0")));
     assert!((((((*arr.borrow())[(0) as usize] as i32) == ('f' as i32)) as i32) != 0));
     assert!((((((*arr.borrow())[(3) as usize] as i32) == ('b' as i32)) as i32) != 0));
     assert!((((((*arr.borrow())[(5) as usize] as i32) == ('r' as i32)) as i32) != 0));
diff --git a/tests/unit/out/refcount/string_literals_sized.rs b/tests/unit/out/refcount/string_literals_sized.rs
index 3715a580..1c1d67df 100644
--- a/tests/unit/out/refcount/string_literals_sized.rs
+++ b/tests/unit/out/refcount/string_literals_sized.rs
@@ -13,21 +13,19 @@ fn main_0() -> i32 {
     let empty_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(vec![0u8; 256].into_boxed_slice()));
     assert!((((*empty_buf.borrow())[(0) as usize] as i32) == (('\0' as u8) as i32)));
     assert!((((*empty_buf.borrow())[(255) as usize] as i32) == (('\0' as u8) as i32)));
-    let prefix_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::<[u8]>::from(
-        b"%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0".as_slice(),
+    let prefix_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(
+        *b"%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
     )));
     assert!((((*prefix_buf.borrow())[(0) as usize] as i32) == (('%' as u8) as i32)));
     assert!((((*prefix_buf.borrow())[(1) as usize] as i32) == (('\0' as u8) as i32)));
     assert!((((*prefix_buf.borrow())[(31) as usize] as i32) == (('\0' as u8) as i32)));
-    let short_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::<[u8]>::from(
-        b"hi\0\0\0\0\0\0\0\0\0\0\0\0\0\0".as_slice(),
-    )));
+    let short_buf: Value<Box<[u8]>> =
+        Rc::new(RefCell::new(Box::from(*b"hi\0\0\0\0\0\0\0\0\0\0\0\0\0\0")));
     assert!((((*short_buf.borrow())[(0) as usize] as i32) == (('h' as u8) as i32)));
     assert!((((*short_buf.borrow())[(1) as usize] as i32) == (('i' as u8) as i32)));
     assert!((((*short_buf.borrow())[(2) as usize] as i32) == (('\0' as u8) as i32)));
     assert!((((*short_buf.borrow())[(15) as usize] as i32) == (('\0' as u8) as i32)));
-    let exact_buf: Value<Box<[u8]>> =
-        Rc::new(RefCell::new(Box::<[u8]>::from(b"hello\0".as_slice())));
+    let exact_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"hello\0")));
     assert!((((*exact_buf.borrow())[(0) as usize] as i32) == (('h' as u8) as i32)));
     assert!((((*exact_buf.borrow())[(4) as usize] as i32) == (('o' as u8) as i32)));
     assert!((((*exact_buf.borrow())[(5) as usize] as i32) == (('\0' as u8) as i32)));
diff --git a/tests/unit/out/refcount/string_literals_sized_c.rs b/tests/unit/out/refcount/string_literals_sized_c.rs
index d1cd783a..296e8ef8 100644
--- a/tests/unit/out/refcount/string_literals_sized_c.rs
+++ b/tests/unit/out/refcount/string_literals_sized_c.rs
@@ -13,21 +13,19 @@ fn main_0() -> i32 {
     let empty_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(vec![0u8; 256].into_boxed_slice()));
     assert!((((((*empty_buf.borrow())[(0) as usize] as i32) == ('\0' as i32)) as i32) != 0));
     assert!((((((*empty_buf.borrow())[(255) as usize] as i32) == ('\0' as i32)) as i32) != 0));
-    let prefix_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::<[u8]>::from(
-        b"%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0".as_slice(),
+    let prefix_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(
+        *b"%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0",
     )));
     assert!((((((*prefix_buf.borrow())[(0) as usize] as i32) == ('%' as i32)) as i32) != 0));
     assert!((((((*prefix_buf.borrow())[(1) as usize] as i32) == ('\0' as i32)) as i32) != 0));
     assert!((((((*prefix_buf.borrow())[(31) as usize] as i32) == ('\0' as i32)) as i32) != 0));
-    let short_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::<[u8]>::from(
-        b"hi\0\0\0\0\0\0\0\0\0\0\0\0\0\0".as_slice(),
-    )));
+    let short_buf: Value<Box<[u8]>> =
+        Rc::new(RefCell::new(Box::from(*b"hi\0\0\0\0\0\0\0\0\0\0\0\0\0\0")));
     assert!((((((*short_buf.borrow())[(0) as usize] as i32) == ('h' as i32)) as i32) != 0));
     assert!((((((*short_buf.borrow())[(1) as usize] as i32) == ('i' as i32)) as i32) != 0));
     assert!((((((*short_buf.borrow())[(2) as usize] as i32) == ('\0' as i32)) as i32) != 0));
     assert!((((((*short_buf.borrow())[(15) as usize] as i32) == ('\0' as i32)) as i32) != 0));
-    let exact_buf: Value<Box<[u8]>> =
-        Rc::new(RefCell::new(Box::<[u8]>::from(b"hello\0".as_slice())));
+    let exact_buf: Value<Box<[u8]>> = Rc::new(RefCell::new(Box::from(*b"hello\0")));
     assert!((((((*exact_buf.borrow())[(0) as usize] as i32) == ('h' as i32)) as i32) != 0));
     assert!((((((*exact_buf.borrow())[(4) as usize] as i32) == ('o' as i32)) as i32) != 0));
     assert!((((((*exact_buf.borrow())[(5) as usize] as i32) == ('\0' as i32)) as i32) != 0));
diff --git a/tests/unit/out/refcount/struct_default_ctor.rs b/tests/unit/out/refcount/struct_default_ctor.rs
index 7f8875a9..39e1bd87 100644
--- a/tests/unit/out/refcount/struct_default_ctor.rs
+++ b/tests/unit/out/refcount/struct_default_ctor.rs
@@ -39,9 +39,7 @@ impl Clone for WOFF2Params {
 }
 impl Default for WOFF2Params {
     fn default() -> Self {
-        {
-            WOFF2Params::WOFF2Params()
-        }
+        { WOFF2Params::WOFF2Params() }
     }
 }
 impl ByteRepr for WOFF2Params {}
diff --git a/tests/unit/out/refcount/vector.rs b/tests/unit/out/refcount/vector.rs
index bbdd2f08..89fd4e39 100644
--- a/tests/unit/out/refcount/vector.rs
+++ b/tests/unit/out/refcount/vector.rs
@@ -76,10 +76,12 @@ fn main_0() -> i32 {
     assert!(((*v4.borrow()).len() == 100_usize));
     let i: Value<u32> = Rc::new(RefCell::new(0_u32));
     'loop_: while (((*i.borrow()) as usize) < (*v4.borrow()).len()) {
-        assert!(((v4.as_pointer() as Ptr<Ptr::<i32>>)
-            .offset(((*i.borrow()) as usize))
-            .read())
-        .is_null());
+        assert!(
+            ((v4.as_pointer() as Ptr<Ptr::<i32>>)
+                .offset(((*i.borrow()) as usize))
+                .read())
+            .is_null()
+        );
         (*i.borrow_mut()).prefix_inc();
     }
     let v5: Value<Vec<Ptr<i32>>> = Rc::new(RefCell::new(
@@ -90,10 +92,12 @@ fn main_0() -> i32 {
     assert!(((*v5.borrow()).len() == 100_usize));
     let i: Value<u32> = Rc::new(RefCell::new(0_u32));
     'loop_: while (((*i.borrow()) as usize) < (*v5.borrow()).len()) {
-        assert!(((v5.as_pointer() as Ptr<Ptr::<i32>>)
-            .offset(((*i.borrow()) as usize))
-            .read())
-        .is_null());
+        assert!(
+            ((v5.as_pointer() as Ptr<Ptr::<i32>>)
+                .offset(((*i.borrow()) as usize))
+                .read())
+            .is_null()
+        );
         (*i.borrow_mut()).prefix_inc();
     }
     let v6: Value<Vec<f64>> = Rc::new(RefCell::new(vec![2.0E+0; (*s2.borrow()) as usize]));
diff --git a/tests/unit/out/unsafe/array_const_init.rs b/tests/unit/out/unsafe/array_const_init.rs
index 4b12092c..7601a660 100644
--- a/tests/unit/out/unsafe/array_const_init.rs
+++ b/tests/unit/out/unsafe/array_const_init.rs
@@ -11,14 +11,14 @@ use std::rc::Rc;
 pub struct S {
     pub head: i32,
     pub tail: [i32; 3],
-    pub buf: [u8; 4],
+    pub buf: [libc::c_char; 4],
 }
 impl Default for S {
     fn default() -> Self {
         S {
             head: 0_i32,
             tail: [0_i32; 3],
-            buf: [0_u8; 4],
+            buf: [(0 as libc::c_char); 4],
         }
     }
 }
diff --git a/tests/unit/out/unsafe/assign_as_value.rs b/tests/unit/out/unsafe/assign_as_value.rs
index eb4cf173..16e13699 100644
--- a/tests/unit/out/unsafe/assign_as_value.rs
+++ b/tests/unit/out/unsafe/assign_as_value.rs
@@ -12,18 +12,18 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut buf: [u8; 2] = [0_u8; 2];
-    let mut p: *mut u8 = buf.as_mut_ptr();
-    let mut q: *mut u8 = std::ptr::null_mut();
+    let mut buf: [libc::c_char; 2] = [(0 as libc::c_char); 2];
+    let mut p: *mut libc::c_char = buf.as_mut_ptr();
+    let mut q: *mut libc::c_char = std::ptr::null_mut();
     q = {
         p = (p).wrapping_add((1 as i32) as usize);
         p
     };
     assert!(((((q) == (buf.as_mut_ptr().offset((1) as isize))) as i32) != 0));
-    let mut out: u8 = 0_u8;
+    let mut out: libc::c_char = (0 as libc::c_char);
     'switch: {
         let __match_cond = (({
-            out = (('x' as i32) as u8);
+            out = (('x' as i32) as libc::c_char);
             out
         }) as i32);
         match __match_cond {
diff --git a/tests/unit/out/unsafe/bool_condition_int.rs b/tests/unit/out/unsafe/bool_condition_int.rs
index ba4559ad..4e65984d 100644
--- a/tests/unit/out/unsafe/bool_condition_int.rs
+++ b/tests/unit/out/unsafe/bool_condition_int.rs
@@ -17,7 +17,7 @@ unsafe fn main_0() -> i32 {
     let mut u: u32 = 4_u32;
     let mut ul: u64 = 5_u64;
     let mut ll: i64 = 6_i64;
-    let mut ch: u8 = ('a' as u8);
+    let mut ch: libc::c_char = ('a' as libc::c_char);
     if (n != 0) {
         assert!(true);
     }
diff --git a/tests/unit/out/unsafe/bool_condition_int_c.rs b/tests/unit/out/unsafe/bool_condition_int_c.rs
index fc4e88eb..e0b28b55 100644
--- a/tests/unit/out/unsafe/bool_condition_int_c.rs
+++ b/tests/unit/out/unsafe/bool_condition_int_c.rs
@@ -17,7 +17,7 @@ unsafe fn main_0() -> i32 {
     let mut u: u32 = 4_u32;
     let mut ul: u64 = 5_u64;
     let mut ll: i64 = 6_i64;
-    let mut ch: u8 = (('a' as i32) as u8);
+    let mut ch: libc::c_char = (('a' as i32) as libc::c_char);
     if (n != 0) {
         assert!((1 != 0));
     }
diff --git a/tests/unit/out/unsafe/bool_condition_logical.rs b/tests/unit/out/unsafe/bool_condition_logical.rs
index d48fc729..da19d85a 100644
--- a/tests/unit/out/unsafe/bool_condition_logical.rs
+++ b/tests/unit/out/unsafe/bool_condition_logical.rs
@@ -114,8 +114,8 @@ unsafe fn main_0() -> i32 {
     if ((n) != (0)) || (((bits) & (256_i64)) != 0) {
         assert!(true);
     }
-    let mut cp: *const u8 = b"hi\0".as_ptr();
-    let mut cnp: *const u8 = std::ptr::null();
+    let mut cp: *const libc::c_char = c"hi".as_ptr();
+    let mut cnp: *const libc::c_char = std::ptr::null();
     if ((x) > (y)) && (!(cp).is_null()) {
         assert!(true);
     }
diff --git a/tests/unit/out/unsafe/bool_condition_logical_c.rs b/tests/unit/out/unsafe/bool_condition_logical_c.rs
index ef45ccdb..602eb54f 100644
--- a/tests/unit/out/unsafe/bool_condition_logical_c.rs
+++ b/tests/unit/out/unsafe/bool_condition_logical_c.rs
@@ -117,8 +117,8 @@ unsafe fn main_0() -> i32 {
     if (((((((n) != (0)) as i32) != 0) || (((bits) & (256_i64)) != 0)) as i32) != 0) {
         assert!((1 != 0));
     }
-    let mut cp: *const u8 = (b"hi\0".as_ptr().cast_mut()).cast_const();
-    let mut cnp: *const u8 = std::ptr::null();
+    let mut cp: *const libc::c_char = (c"hi".as_ptr().cast_mut()).cast_const();
+    let mut cnp: *const libc::c_char = std::ptr::null();
     if (((((((x) > (y)) as i32) != 0) && (!(cp).is_null())) as i32) != 0) {
         assert!((1 != 0));
     }
diff --git a/tests/unit/out/unsafe/borrow_mut_opt.rs b/tests/unit/out/unsafe/borrow_mut_opt.rs
index 9f53ea00..1aa8e5ae 100644
--- a/tests/unit/out/unsafe/borrow_mut_opt.rs
+++ b/tests/unit/out/unsafe/borrow_mut_opt.rs
@@ -22,9 +22,13 @@ pub unsafe fn convert_without_rhs_0() {
     let mut arr: [i32; 2] = [1, 2];
     let mut w: i32 = ((arr[(y) as usize]) + (arr[(x) as usize]));
     w += (((z) + (y)) + (x));
-    let mut arr2: [u8; 3] = [('a' as u8), ('b' as u8), ('c' as u8)];
+    let mut arr2: [libc::c_char; 3] = [
+        ('a' as libc::c_char),
+        ('b' as libc::c_char),
+        ('c' as libc::c_char),
+    ];
     let mut p1: *const i32 = (&mut x as *mut i32).cast_const();
-    let mut c: u8 = arr2[(*p1) as usize];
+    let mut c: libc::c_char = arr2[(*p1) as usize];
     c = arr2[(*p1) as usize];
     let mut p2: *mut i32 = (&mut x as *mut i32);
     (*p2) = 1;
diff --git a/tests/unit/out/unsafe/cast_array_to_pointer_decay.rs b/tests/unit/out/unsafe/cast_array_to_pointer_decay.rs
index fa4c5518..76d83cdf 100644
--- a/tests/unit/out/unsafe/cast_array_to_pointer_decay.rs
+++ b/tests/unit/out/unsafe/cast_array_to_pointer_decay.rs
@@ -9,7 +9,7 @@ use std::rc::Rc;
 pub unsafe fn deref_0(mut p: *mut i32) -> i32 {
     return (*p);
 }
-pub unsafe fn strlen_1(mut s: *mut u8) -> i32 {
+pub unsafe fn strlen_1(mut s: *mut libc::c_char) -> i32 {
     let mut c: i32 = 0;
     'loop_: while ((*s.postfix_inc()) != 0) {
         c.prefix_inc();
@@ -23,6 +23,11 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut a: [i32; 2] = [1, 2];
-    let mut s: [u8; 4] = [('a' as u8), ('b' as u8), ('c' as u8), ('\0' as u8)];
+    let mut s: [libc::c_char; 4] = [
+        ('a' as libc::c_char),
+        ('b' as libc::c_char),
+        ('c' as libc::c_char),
+        ('\0' as libc::c_char),
+    ];
     return ((unsafe { deref_0(a.as_mut_ptr()) }) + (unsafe { strlen_1(s.as_mut_ptr()) }));
 }
diff --git a/tests/unit/out/unsafe/char_printing.rs b/tests/unit/out/unsafe/char_printing.rs
index 965d6df7..72076f39 100644
--- a/tests/unit/out/unsafe/char_printing.rs
+++ b/tests/unit/out/unsafe/char_printing.rs
@@ -14,8 +14,8 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut vec_: Vec<u8> = vec![195_u8, 167_u8];
     let mut i: i32 = 27;
-    let mut str: Vec<u8> = {
-        let s = b"rdas.\0".as_ptr();
+    let mut str: Vec<libc::c_char> = {
+        let s = c"rdas.".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
     write!(
@@ -38,10 +38,14 @@ unsafe fn main_0() -> i32 {
     )
     .write_all(
         &([
-            (&[vec_[(0_usize)]] as &[u8]),
-            (&[vec_[(1_usize)]] as &[u8]),
-            (&[('o' as u8)] as &[u8]),
-            (&(str)[..(str).len() - 1] as &[u8]),
+            (&[vec_[(0_usize)] as u8] as &[u8]),
+            (&[vec_[(1_usize)] as u8] as &[u8]),
+            (&[('o' as libc::c_char) as u8] as &[u8]),
+            (&(str)
+                .iter()
+                .take((str).len() - 1)
+                .map(|&c| c as u8)
+                .collect::<Vec<u8>>()[..] as &[u8]),
             (&[b'\n'] as &[u8]),
         ]
         .concat()),
@@ -67,7 +71,7 @@ unsafe fn main_0() -> i32 {
     .write_all(
         &([
             (b" a\xc3\xa7ordas?" as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
+            (&[('\n' as libc::c_char) as u8] as &[u8]),
             (b"Sim, 0x" as &[u8]),
         ]
         .concat()),
@@ -102,10 +106,10 @@ unsafe fn main_0() -> i32 {
     )
     .write_all(
         &([
-            (&[vec_[(0_usize)]] as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
-            (&[vec_[(1_usize)]] as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
+            (&[vec_[(0_usize)] as u8] as &[u8]),
+            (&[('\n' as libc::c_char) as u8] as &[u8]),
+            (&[vec_[(1_usize)] as u8] as &[u8]),
+            (&[('\n' as libc::c_char) as u8] as &[u8]),
         ]
         .concat()),
     );
diff --git a/tests/unit/out/unsafe/char_printing_cerr.rs b/tests/unit/out/unsafe/char_printing_cerr.rs
index 8fc459be..acd53963 100644
--- a/tests/unit/out/unsafe/char_printing_cerr.rs
+++ b/tests/unit/out/unsafe/char_printing_cerr.rs
@@ -14,8 +14,8 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut vec_: Vec<u8> = vec![195_u8, 167_u8];
     let mut i: i32 = 27;
-    let mut str: Vec<u8> = {
-        let s = b"rdas.\0".as_ptr();
+    let mut str: Vec<libc::c_char> = {
+        let s = c"rdas.".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
     write!(
@@ -38,10 +38,14 @@ unsafe fn main_0() -> i32 {
     )
     .write_all(
         &([
-            (&[vec_[(0_usize)]] as &[u8]),
-            (&[vec_[(1_usize)]] as &[u8]),
-            (&[('o' as u8)] as &[u8]),
-            (&(str)[..(str).len() - 1] as &[u8]),
+            (&[vec_[(0_usize)] as u8] as &[u8]),
+            (&[vec_[(1_usize)] as u8] as &[u8]),
+            (&[('o' as libc::c_char) as u8] as &[u8]),
+            (&(str)
+                .iter()
+                .take((str).len() - 1)
+                .map(|&c| c as u8)
+                .collect::<Vec<u8>>()[..] as &[u8]),
             (&[b'\n'] as &[u8]),
         ]
         .concat()),
@@ -67,7 +71,7 @@ unsafe fn main_0() -> i32 {
     .write_all(
         &([
             (b" a\xc3\xa7ordas?" as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
+            (&[('\n' as libc::c_char) as u8] as &[u8]),
             (b"Sim, 0x" as &[u8]),
         ]
         .concat()),
@@ -102,10 +106,10 @@ unsafe fn main_0() -> i32 {
     )
     .write_all(
         &([
-            (&[vec_[(0_usize)]] as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
-            (&[vec_[(1_usize)]] as &[u8]),
-            (&[('\n' as u8)] as &[u8]),
+            (&[vec_[(0_usize)] as u8] as &[u8]),
+            (&[('\n' as libc::c_char) as u8] as &[u8]),
+            (&[vec_[(1_usize)] as u8] as &[u8]),
+            (&[('\n' as libc::c_char) as u8] as &[u8]),
         ]
         .concat()),
     );
diff --git a/tests/unit/out/unsafe/class_templates.rs b/tests/unit/out/unsafe/class_templates.rs
index 151ccbf1..04187cce 100644
--- a/tests/unit/out/unsafe/class_templates.rs
+++ b/tests/unit/out/unsafe/class_templates.rs
@@ -38,7 +38,7 @@ impl MyContainer_int_ {
 #[repr(C)]
 #[derive(Clone, Default)]
 pub struct MyContainer_char_ {
-    vec_: Vec<u8>,
+    vec_: Vec<libc::c_char>,
 }
 impl MyContainer_char_ {
     pub unsafe fn empty(&self) -> bool {
@@ -47,17 +47,17 @@ impl MyContainer_char_ {
     pub unsafe fn size(&self) -> usize {
         return self.vec_.len();
     }
-    pub unsafe fn back_const(&self) -> *const u8 {
+    pub unsafe fn back_const(&self) -> *const libc::c_char {
         return ((self.vec_).last().unwrap());
     }
-    pub unsafe fn back(&mut self) -> *mut u8 {
+    pub unsafe fn back(&mut self) -> *mut libc::c_char {
         return ((self.vec_).last_mut().unwrap());
     }
     pub unsafe fn pop_back(&mut self) {
         self.vec_.pop();
         return;
     }
-    pub unsafe fn push_back(&mut self, item: *const u8) {
+    pub unsafe fn push_back(&mut self, item: *const libc::c_char) {
         {
             let a0_clone = (*item).clone();
             self.vec_.push(a0_clone)
@@ -111,12 +111,12 @@ unsafe fn main_0() -> i32 {
     let mut cmc: MyContainer_char_ = <MyContainer_char_>::default();
     assert!((unsafe { cmc.empty() }));
     (unsafe {
-        let mut _item = ('a' as u8);
+        let mut _item = ('a' as libc::c_char);
         cmc.push_back(&mut _item)
     });
     assert!(
         ((unsafe { cmc.size() }) == (1_usize))
-            && (((*(unsafe { cmc.back() })) as i32) == (('a' as u8) as i32))
+            && (((*(unsafe { cmc.back() })) as i32) == (('a' as libc::c_char) as i32))
     );
     (unsafe { cmc.pop_back() });
     assert!((unsafe { cmc.empty() }));
diff --git a/tests/unit/out/unsafe/clone_vs_move.rs b/tests/unit/out/unsafe/clone_vs_move.rs
index 249f8352..281f9806 100644
--- a/tests/unit/out/unsafe/clone_vs_move.rs
+++ b/tests/unit/out/unsafe/clone_vs_move.rs
@@ -210,21 +210,21 @@ unsafe fn main_0() -> i32 {
     assert!(((pair4.1) == (1)));
     assert!(((pair3.0.len()) == (0_usize)));
     assert!(((pair3.1) == (0)));
-    let mut s1: Vec<u8> = vec![('a' as u8); (3_usize) as usize]
+    let mut s1: Vec<libc::c_char> = vec![('a' as libc::c_char); (3_usize) as usize]
         .iter()
         .cloned()
         .chain(std::iter::once(0))
         .collect();
-    let mut s2: Vec<u8> = s1.clone();
-    s2[(0_usize)] = ('b' as u8);
-    s2[(1_usize)] = ('b' as u8);
-    s2[(2_usize)] = ('b' as u8);
-    assert!(((s2[(0_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((s2[(1_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((s2[(2_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((s1[(0_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((s1[(1_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((s1[(2_usize)] as i32) == (('a' as u8) as i32)));
+    let mut s2: Vec<libc::c_char> = s1.clone();
+    s2[(0_usize)] = ('b' as libc::c_char);
+    s2[(1_usize)] = ('b' as libc::c_char);
+    s2[(2_usize)] = ('b' as libc::c_char);
+    assert!(((s2[(0_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((s2[(1_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((s2[(2_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((s1[(0_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((s1[(1_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((s1[(2_usize)] as i32) == (('a' as libc::c_char) as i32)));
     let mut b1: Bar = Bar { w: 1 };
     let mut b2: Bar = Bar { w: 2 };
     b2 = b1;
diff --git a/tests/unit/out/unsafe/cstring.rs b/tests/unit/out/unsafe/cstring.rs
index 9583cbb2..79cd9166 100644
--- a/tests/unit/out/unsafe/cstring.rs
+++ b/tests/unit/out/unsafe/cstring.rs
@@ -7,59 +7,81 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn test_memcpy_0() {
-    let src: [u8; 6] = *b"hello\0";
-    let mut dst: [u8; 6] = [0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8];
+    let src: [libc::c_char; 6] = std::mem::transmute(*b"hello\0");
+    let mut dst: [libc::c_char; 6] = [
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+    ];
     let mut r: *mut ::libc::c_void = {
         if 6_usize != 0 {
             ::std::ptr::copy_nonoverlapping(
-                (src.as_ptr() as *const u8 as *const ::libc::c_void),
-                (dst.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+                (src.as_ptr() as *const libc::c_char as *const ::libc::c_void),
+                (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
                 6_usize as usize,
             )
         }
-        (dst.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+        (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
     };
-    assert!(((r) == (dst.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)));
+    assert!(((r) == (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)));
     assert!(
-        (((dst[(0) as usize] as i32) == (('h' as u8) as i32))
-            && ((dst[(1) as usize] as i32) == (('e' as u8) as i32)))
-            && ((dst[(2) as usize] as i32) == (('l' as u8) as i32))
+        (((dst[(0) as usize] as i32) == (('h' as libc::c_char) as i32))
+            && ((dst[(1) as usize] as i32) == (('e' as libc::c_char) as i32)))
+            && ((dst[(2) as usize] as i32) == (('l' as libc::c_char) as i32))
     );
     assert!(
-        (((dst[(3) as usize] as i32) == (('l' as u8) as i32))
-            && ((dst[(4) as usize] as i32) == (('o' as u8) as i32)))
-            && ((dst[(5) as usize] as i32) == (('\0' as u8) as i32))
+        (((dst[(3) as usize] as i32) == (('l' as libc::c_char) as i32))
+            && ((dst[(4) as usize] as i32) == (('o' as libc::c_char) as i32)))
+            && ((dst[(5) as usize] as i32) == (('\0' as libc::c_char) as i32))
     );
 }
 pub unsafe fn test_memset_1() {
-    let mut buf: [u8; 4] = [0_u8; 4];
+    let mut buf: [libc::c_char; 4] = [(0 as libc::c_char); 4];
     let mut r: *mut ::libc::c_void = {
-        let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
+        let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8;
         for offset in 0..4_usize {
-            *byte_0.offset(offset as isize) = (('x' as u8) as i32) as u8;
+            *byte_0.offset(offset as isize) = (('x' as libc::c_char) as i32) as u8;
         }
-        (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+        (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
     };
-    assert!(((r) == (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)));
+    assert!(((r) == (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)));
     assert!(
-        ((((buf[(0) as usize] as i32) == (('x' as u8) as i32))
-            && ((buf[(1) as usize] as i32) == (('x' as u8) as i32)))
-            && ((buf[(2) as usize] as i32) == (('x' as u8) as i32)))
-            && ((buf[(3) as usize] as i32) == (('x' as u8) as i32))
+        ((((buf[(0) as usize] as i32) == (('x' as libc::c_char) as i32))
+            && ((buf[(1) as usize] as i32) == (('x' as libc::c_char) as i32)))
+            && ((buf[(2) as usize] as i32) == (('x' as libc::c_char) as i32)))
+            && ((buf[(3) as usize] as i32) == (('x' as libc::c_char) as i32))
     );
 }
 pub unsafe fn test_memcmp_2() {
-    let a: [u8; 4] = [1_u8, 2_u8, 3_u8, 4_u8];
-    let b: [u8; 4] = [1_u8, 2_u8, 3_u8, 4_u8];
-    let c: [u8; 4] = [1_u8, 2_u8, 9_u8, 4_u8];
+    let a: [libc::c_char; 4] = [
+        (1 as libc::c_char),
+        (2 as libc::c_char),
+        (3 as libc::c_char),
+        (4 as libc::c_char),
+    ];
+    let b: [libc::c_char; 4] = [
+        (1 as libc::c_char),
+        (2 as libc::c_char),
+        (3 as libc::c_char),
+        (4 as libc::c_char),
+    ];
+    let c: [libc::c_char; 4] = [
+        (1 as libc::c_char),
+        (2 as libc::c_char),
+        (9 as libc::c_char),
+        (4 as libc::c_char),
+    ];
     assert!(
         (({
             let sa = core::slice::from_raw_parts(
-                (a.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (b.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (b.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let mut diff = 0_i32;
@@ -75,11 +97,11 @@ pub unsafe fn test_memcmp_2() {
     assert!(
         (({
             let sa = core::slice::from_raw_parts(
-                (a.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (c.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let mut diff = 0_i32;
@@ -95,11 +117,11 @@ pub unsafe fn test_memcmp_2() {
     assert!(
         (({
             let sa = core::slice::from_raw_parts(
-                (c.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (a.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let mut diff = 0_i32;
@@ -114,139 +136,115 @@ pub unsafe fn test_memcmp_2() {
     );
 }
 pub unsafe fn test_memmove_3() {
-    let mut buf: [u8; 6] = [
-        ('a' as u8),
-        ('b' as u8),
-        ('c' as u8),
-        ('d' as u8),
-        ('e' as u8),
-        ('\0' as u8),
+    let mut buf: [libc::c_char; 6] = [
+        ('a' as libc::c_char),
+        ('b' as libc::c_char),
+        ('c' as libc::c_char),
+        ('d' as libc::c_char),
+        ('e' as libc::c_char),
+        ('\0' as libc::c_char),
     ];
     let mut r: *mut ::libc::c_void = {
         if 4_usize != 0 {
             ::std::ptr::copy_nonoverlapping(
-                (buf.as_mut_ptr() as *const u8 as *const ::libc::c_void),
-                (buf.as_mut_ptr().offset((1) as isize) as *mut u8 as *mut ::libc::c_void),
+                (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void),
+                (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void),
                 4_usize as usize,
             )
         }
-        (buf.as_mut_ptr().offset((1) as isize) as *mut u8 as *mut ::libc::c_void)
+        (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void)
     };
-    assert!(((r) == (buf.as_mut_ptr().offset((1) as isize) as *mut u8 as *mut ::libc::c_void)));
     assert!(
-        (((buf[(0) as usize] as i32) == (('a' as u8) as i32))
-            && ((buf[(1) as usize] as i32) == (('a' as u8) as i32)))
-            && ((buf[(2) as usize] as i32) == (('b' as u8) as i32))
+        ((r) == (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char
+            as *mut ::libc::c_void))
     );
     assert!(
-        (((buf[(3) as usize] as i32) == (('c' as u8) as i32))
-            && ((buf[(4) as usize] as i32) == (('d' as u8) as i32)))
-            && ((buf[(5) as usize] as i32) == (('\0' as u8) as i32))
+        (((buf[(0) as usize] as i32) == (('a' as libc::c_char) as i32))
+            && ((buf[(1) as usize] as i32) == (('a' as libc::c_char) as i32)))
+            && ((buf[(2) as usize] as i32) == (('b' as libc::c_char) as i32))
+    );
+    assert!(
+        (((buf[(3) as usize] as i32) == (('c' as libc::c_char) as i32))
+            && ((buf[(4) as usize] as i32) == (('d' as libc::c_char) as i32)))
+            && ((buf[(5) as usize] as i32) == (('\0' as libc::c_char) as i32))
     );
 }
 pub unsafe fn test_strchr_4() {
-    let mut s: *const u8 = b"hello world\0".as_ptr();
-    let mut r: *const u8 = libc::strchr(s as *const i8, (('w' as u8) as i32)) as *const u8;
+    let mut s: *const libc::c_char = c"hello world".as_ptr();
+    let mut r: *const libc::c_char =
+        (libc::strchr(s, (('w' as libc::c_char) as i32)) as *const libc::c_char);
     assert!(!((r).is_null()));
-    assert!((((*r) as i32) == (('w' as u8) as i32)));
-    assert!((libc::strchr(s as *const i8, (('z' as u8) as i32)) as *const u8).is_null());
+    assert!((((*r) as i32) == (('w' as libc::c_char) as i32)));
+    assert!((libc::strchr(s, (('z' as libc::c_char) as i32)) as *const libc::c_char).is_null());
 }
 pub unsafe fn test_strlen_5() {
-    assert!(((libc::strlen(b"\0".as_ptr() as *const i8)) == (0_usize)));
-    assert!(((libc::strlen(b"hello\0".as_ptr() as *const i8)) == (5_usize)));
-    assert!(((libc::strlen(b"hello world\0".as_ptr() as *const i8)) == (11_usize)));
+    assert!(((libc::strlen(c"".as_ptr())) == (0_usize)));
+    assert!(((libc::strlen(c"hello".as_ptr())) == (5_usize)));
+    assert!(((libc::strlen(c"hello world".as_ptr())) == (11_usize)));
 }
 pub unsafe fn test_strcmp_6() {
-    assert!(
-        ((libc::strcmp(
-            b"abc\0".as_ptr() as *const i8,
-            b"abc\0".as_ptr() as *const i8
-        )) == (0))
-    );
-    assert!(
-        ((libc::strcmp(
-            b"abc\0".as_ptr() as *const i8,
-            b"abd\0".as_ptr() as *const i8
-        )) < (0))
-    );
-    assert!(
-        ((libc::strcmp(
-            b"abd\0".as_ptr() as *const i8,
-            b"abc\0".as_ptr() as *const i8
-        )) > (0))
-    );
-    let mut p: *const u8 = b"abc\0".as_ptr();
-    let mut q: *const u8 = b"abd\0".as_ptr();
-    let mut buf: [u8; 4] = [('a' as u8), ('b' as u8), ('c' as u8), ('\0' as u8)];
-    assert!(((libc::strcmp(p as *const i8, p as *const i8)) == (0)));
-    assert!(((libc::strcmp(p as *const i8, q as *const i8)) < (0)));
-    assert!(((libc::strcmp((buf.as_mut_ptr()).cast_const() as *const i8, p as *const i8)) == (0)));
+    assert!(((libc::strcmp(c"abc".as_ptr(), c"abc".as_ptr())) == (0)));
+    assert!(((libc::strcmp(c"abc".as_ptr(), c"abd".as_ptr())) < (0)));
+    assert!(((libc::strcmp(c"abd".as_ptr(), c"abc".as_ptr())) > (0)));
+    let mut p: *const libc::c_char = c"abc".as_ptr();
+    let mut q: *const libc::c_char = c"abd".as_ptr();
+    let mut buf: [libc::c_char; 4] = [
+        ('a' as libc::c_char),
+        ('b' as libc::c_char),
+        ('c' as libc::c_char),
+        ('\0' as libc::c_char),
+    ];
+    assert!(((libc::strcmp(p, p)) == (0)));
+    assert!(((libc::strcmp(p, q)) < (0)));
+    assert!(((libc::strcmp((buf.as_mut_ptr()).cast_const(), p)) == (0)));
 }
 pub unsafe fn test_strncmp_7() {
-    assert!(
-        ((libc::strncmp(
-            b"abcdef\0".as_ptr() as *const i8,
-            b"abcxyz\0".as_ptr() as *const i8,
-            3_usize as usize
-        )) == (0))
-    );
-    assert!(
-        ((libc::strncmp(
-            b"abcdef\0".as_ptr() as *const i8,
-            b"abcxyz\0".as_ptr() as *const i8,
-            4_usize as usize
-        )) < (0))
-    );
-    assert!(
-        ((libc::strncmp(
-            b"abcxyz\0".as_ptr() as *const i8,
-            b"abcdef\0".as_ptr() as *const i8,
-            4_usize as usize
-        )) > (0))
-    );
-    let mut p: *const u8 = b"abcdef\0".as_ptr();
-    let mut q: *const u8 = b"abcxyz\0".as_ptr();
-    let mut buf: [u8; 7] = [
-        ('a' as u8),
-        ('b' as u8),
-        ('c' as u8),
-        ('d' as u8),
-        ('e' as u8),
-        ('f' as u8),
-        ('\0' as u8),
+    assert!(((libc::strncmp(c"abcdef".as_ptr(), c"abcxyz".as_ptr(), 3_usize as usize)) == (0)));
+    assert!(((libc::strncmp(c"abcdef".as_ptr(), c"abcxyz".as_ptr(), 4_usize as usize)) < (0)));
+    assert!(((libc::strncmp(c"abcxyz".as_ptr(), c"abcdef".as_ptr(), 4_usize as usize)) > (0)));
+    let mut p: *const libc::c_char = c"abcdef".as_ptr();
+    let mut q: *const libc::c_char = c"abcxyz".as_ptr();
+    let mut buf: [libc::c_char; 7] = [
+        ('a' as libc::c_char),
+        ('b' as libc::c_char),
+        ('c' as libc::c_char),
+        ('d' as libc::c_char),
+        ('e' as libc::c_char),
+        ('f' as libc::c_char),
+        ('\0' as libc::c_char),
     ];
     let mut n: usize = 3_usize;
-    assert!(((libc::strncmp(p as *const i8, q as *const i8, n as usize)) == (0)));
-    assert!(
-        ((libc::strncmp(
-            p as *const i8,
-            q as *const i8,
-            (n).wrapping_add(1_usize) as usize
-        )) < (0))
-    );
-    assert!(
-        ((libc::strncmp(
-            (buf.as_mut_ptr()).cast_const() as *const i8,
-            p as *const i8,
-            6_usize as usize
-        )) == (0))
-    );
+    assert!(((libc::strncmp(p, q, n as usize)) == (0)));
+    assert!(((libc::strncmp(p, q, (n).wrapping_add(1_usize) as usize)) < (0)));
+    assert!(((libc::strncmp((buf.as_mut_ptr()).cast_const(), p, 6_usize as usize)) == (0)));
 }
 pub unsafe fn test_memchr_8() {
-    let data: [u8; 4] = [16_u8, 32_u8, 48_u8, 64_u8];
+    let data: [libc::c_char; 4] = [
+        (16 as libc::c_char),
+        (32 as libc::c_char),
+        (48 as libc::c_char),
+        (64 as libc::c_char),
+    ];
     let mut r: *const ::libc::c_void = libc::memchr(
-        (data.as_ptr() as *const u8 as *const ::libc::c_void) as *const ::libc::c_void,
+        (data.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const ::libc::c_void,
         48,
         4_usize as usize,
     ) as *const ::libc::c_void;
-    assert!(((r) == ((&data[(2) as usize] as *const u8) as *const u8 as *const ::libc::c_void)));
-    assert!((libc::memchr(
-        (data.as_ptr() as *const u8 as *const ::libc::c_void) as *const ::libc::c_void,
-        153,
-        4_usize as usize
-    ) as *const ::libc::c_void)
-        .is_null());
-    let mut p: *const ::libc::c_void = (data.as_ptr() as *const u8 as *const ::libc::c_void);
+    assert!(
+        ((r) == ((&data[(2) as usize] as *const libc::c_char) as *const libc::c_char
+            as *const ::libc::c_void))
+    );
+    assert!(
+        (libc::memchr(
+            (data.as_ptr() as *const libc::c_char as *const ::libc::c_void)
+                as *const ::libc::c_void,
+            153,
+            4_usize as usize
+        ) as *const ::libc::c_void)
+            .is_null()
+    );
+    let mut p: *const ::libc::c_void =
+        (data.as_ptr() as *const libc::c_char as *const ::libc::c_void);
     let mut n: usize = 4_usize;
     assert!(
         ((libc::memchr(p as *const ::libc::c_void, 16, n as usize) as *const ::libc::c_void)
@@ -254,139 +252,104 @@ pub unsafe fn test_memchr_8() {
     );
 }
 pub unsafe fn test_strrchr_9() {
-    let mut s: *const u8 = b"hello world\0".as_ptr();
-    let mut r: *const u8 = libc::strrchr(s as *const i8, (('l' as u8) as i32)) as *const u8;
+    let mut s: *const libc::c_char = c"hello world".as_ptr();
+    let mut r: *const libc::c_char =
+        (libc::strrchr(s, (('l' as libc::c_char) as i32)) as *const libc::c_char);
     assert!(!((r).is_null()));
-    assert!((((*r) as i32) == (('l' as u8) as i32)));
+    assert!((((*r) as i32) == (('l' as libc::c_char) as i32)));
     assert!(((r) == (s.offset((9) as isize))));
-    assert!((libc::strrchr(s as *const i8, (('z' as u8) as i32)) as *const u8).is_null());
-    let mut buf: [u8; 4] = [('a' as u8), ('b' as u8), ('a' as u8), ('\0' as u8)];
+    assert!((libc::strrchr(s, (('z' as libc::c_char) as i32)) as *const libc::c_char).is_null());
+    let mut buf: [libc::c_char; 4] = [
+        ('a' as libc::c_char),
+        ('b' as libc::c_char),
+        ('a' as libc::c_char),
+        ('\0' as libc::c_char),
+    ];
     assert!(
-        ((libc::strrchr(buf.as_mut_ptr() as *const i8, (('a' as u8) as i32)) as *mut u8)
-            == (&mut buf[(2) as usize] as *mut u8))
+        ((libc::strrchr(buf.as_mut_ptr(), (('a' as libc::c_char) as i32)))
+            == (&mut buf[(2) as usize] as *mut libc::c_char))
     );
 }
 pub unsafe fn test_strdup_10() {
-    let mut d: *mut u8 = libcc2rs::strdup_unsafe(b"hello\0".as_ptr());
+    let mut d: *mut libc::c_char = libcc2rs::strdup_unsafe(c"hello".as_ptr());
     assert!(!((d).is_null()));
-    assert!(
-        ((libc::strcmp(
-            (d).cast_const() as *const i8,
-            b"hello\0".as_ptr() as *const i8
-        )) == (0))
-    );
-    libcc2rs::free_unsafe((d as *mut u8 as *mut ::libc::c_void));
-    let mut p: *const u8 = b"world\0".as_ptr();
-    let mut buf: [u8; 4] = [('a' as u8), ('b' as u8), ('c' as u8), ('\0' as u8)];
-    let mut d2: *mut u8 = libcc2rs::strdup_unsafe(p);
+    assert!(((libc::strcmp((d).cast_const(), c"hello".as_ptr())) == (0)));
+    libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void));
+    let mut p: *const libc::c_char = c"world".as_ptr();
+    let mut buf: [libc::c_char; 4] = [
+        ('a' as libc::c_char),
+        ('b' as libc::c_char),
+        ('c' as libc::c_char),
+        ('\0' as libc::c_char),
+    ];
+    let mut d2: *mut libc::c_char = libcc2rs::strdup_unsafe(p);
     assert!(!((d2).is_null()));
-    assert!(((libc::strcmp((d2).cast_const() as *const i8, p as *const i8)) == (0)));
-    libcc2rs::free_unsafe((d2 as *mut u8 as *mut ::libc::c_void));
-    let mut d3: *mut u8 = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const());
+    assert!(((libc::strcmp((d2).cast_const(), p)) == (0)));
+    libcc2rs::free_unsafe((d2 as *mut libc::c_char as *mut ::libc::c_void));
+    let mut d3: *mut libc::c_char = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const());
     assert!(!((d3).is_null()));
-    assert!(
-        ((libc::strcmp(
-            (d3).cast_const() as *const i8,
-            (buf.as_mut_ptr()).cast_const() as *const i8
-        )) == (0))
-    );
-    libcc2rs::free_unsafe((d3 as *mut u8 as *mut ::libc::c_void));
+    assert!(((libc::strcmp((d3).cast_const(), (buf.as_mut_ptr()).cast_const())) == (0)));
+    libcc2rs::free_unsafe((d3 as *mut libc::c_char as *mut ::libc::c_void));
 }
 pub unsafe fn test_strcspn_11() {
-    assert!(
-        ((libc::strcspn(
-            b"hello\0".as_ptr() as *const i8,
-            b"el\0".as_ptr() as *const i8
-        )) == (1_usize))
-    );
-    assert!(
-        ((libc::strcspn(
-            b"abc\0".as_ptr() as *const i8,
-            b"xyz\0".as_ptr() as *const i8
-        )) == (3_usize))
-    );
-    assert!(
-        ((libc::strcspn(b"\0".as_ptr() as *const i8, b"abc\0".as_ptr() as *const i8)) == (0_usize))
-    );
-    let mut s: *const u8 = b"hello\0".as_ptr();
-    let mut rej: *const u8 = b"el\0".as_ptr();
-    assert!(((libc::strcspn(s as *const i8, rej as *const i8)) == (1_usize)));
+    assert!(((libc::strcspn(c"hello".as_ptr(), c"el".as_ptr())) == (1_usize)));
+    assert!(((libc::strcspn(c"abc".as_ptr(), c"xyz".as_ptr())) == (3_usize)));
+    assert!(((libc::strcspn(c"".as_ptr(), c"abc".as_ptr())) == (0_usize)));
+    let mut s: *const libc::c_char = c"hello".as_ptr();
+    let mut rej: *const libc::c_char = c"el".as_ptr();
+    assert!(((libc::strcspn(s, rej)) == (1_usize)));
 }
 pub unsafe fn test_strspn_12() {
-    assert!(
-        ((libc::strspn(
-            b"hello\0".as_ptr() as *const i8,
-            b"hel\0".as_ptr() as *const i8
-        )) == (4_usize))
-    );
-    assert!(
-        ((libc::strspn(
-            b"abc\0".as_ptr() as *const i8,
-            b"xyz\0".as_ptr() as *const i8
-        )) == (0_usize))
-    );
-    assert!(
-        ((libc::strspn(b"aaa\0".as_ptr() as *const i8, b"a\0".as_ptr() as *const i8)) == (3_usize))
-    );
-    let mut s: *const u8 = b"hello\0".as_ptr();
-    let mut acc: *const u8 = b"hel\0".as_ptr();
-    assert!(((libc::strspn(s as *const i8, acc as *const i8)) == (4_usize)));
+    assert!(((libc::strspn(c"hello".as_ptr(), c"hel".as_ptr())) == (4_usize)));
+    assert!(((libc::strspn(c"abc".as_ptr(), c"xyz".as_ptr())) == (0_usize)));
+    assert!(((libc::strspn(c"aaa".as_ptr(), c"a".as_ptr())) == (3_usize)));
+    let mut s: *const libc::c_char = c"hello".as_ptr();
+    let mut acc: *const libc::c_char = c"hel".as_ptr();
+    assert!(((libc::strspn(s, acc)) == (4_usize)));
 }
 pub unsafe fn test_strstr_13() {
-    let mut h: *const u8 = b"hello world\0".as_ptr();
-    let mut r: *const u8 =
-        libc::strstr(h as *const i8, b"world\0".as_ptr() as *const i8) as *const u8;
+    let mut h: *const libc::c_char = c"hello world".as_ptr();
+    let mut r: *const libc::c_char = (libc::strstr(h, c"world".as_ptr()) as *const libc::c_char);
     assert!(!((r).is_null()));
     assert!(((r) == (h.offset((6) as isize))));
-    assert!((libc::strstr(h as *const i8, b"xyz\0".as_ptr() as *const i8) as *const u8).is_null());
-    let mut buf: [u8; 6] = [
-        ('h' as u8),
-        ('e' as u8),
-        ('l' as u8),
-        ('l' as u8),
-        ('o' as u8),
-        ('\0' as u8),
+    assert!((libc::strstr(h, c"xyz".as_ptr()) as *const libc::c_char).is_null());
+    let mut buf: [libc::c_char; 6] = [
+        ('h' as libc::c_char),
+        ('e' as libc::c_char),
+        ('l' as libc::c_char),
+        ('l' as libc::c_char),
+        ('o' as libc::c_char),
+        ('\0' as libc::c_char),
     ];
     assert!(
-        ((libc::strstr(buf.as_mut_ptr() as *const i8, b"ll\0".as_ptr() as *const i8) as *mut u8)
-            == (&mut buf[(2) as usize] as *mut u8))
+        ((libc::strstr(buf.as_mut_ptr(), c"ll".as_ptr()))
+            == (&mut buf[(2) as usize] as *mut libc::c_char))
     );
 }
 pub unsafe fn test_strpbrk_14() {
-    let mut s: *const u8 = b"hello world\0".as_ptr();
-    let mut r: *const u8 =
-        libc::strpbrk(s as *const i8, b"wo\0".as_ptr() as *const i8) as *const u8;
+    let mut s: *const libc::c_char = c"hello world".as_ptr();
+    let mut r: *const libc::c_char = (libc::strpbrk(s, c"wo".as_ptr()) as *const libc::c_char);
     assert!(!((r).is_null()));
     assert!(((r) == (s.offset((4) as isize))));
-    assert!((libc::strpbrk(s as *const i8, b"xyz\0".as_ptr() as *const i8) as *const u8).is_null());
-    let mut buf: [u8; 4] = [('a' as u8), ('b' as u8), ('c' as u8), ('\0' as u8)];
+    assert!((libc::strpbrk(s, c"xyz".as_ptr()) as *const libc::c_char).is_null());
+    let mut buf: [libc::c_char; 4] = [
+        ('a' as libc::c_char),
+        ('b' as libc::c_char),
+        ('c' as libc::c_char),
+        ('\0' as libc::c_char),
+    ];
     assert!(
-        ((libc::strpbrk(buf.as_mut_ptr() as *const i8, b"b\0".as_ptr() as *const i8) as *mut u8)
-            == (&mut buf[(1) as usize] as *mut u8))
+        ((libc::strpbrk(buf.as_mut_ptr(), c"b".as_ptr()))
+            == (&mut buf[(1) as usize] as *mut libc::c_char))
     );
 }
 pub unsafe fn test_strcasecmp_15() {
-    assert!(
-        ((libc::strcasecmp(
-            b"HELLO\0".as_ptr() as *const i8,
-            b"hello\0".as_ptr() as *const i8
-        )) == (0))
-    );
-    assert!(
-        ((libc::strcasecmp(
-            b"abc\0".as_ptr() as *const i8,
-            b"abd\0".as_ptr() as *const i8
-        )) < (0))
-    );
-    assert!(
-        ((libc::strcasecmp(
-            b"abd\0".as_ptr() as *const i8,
-            b"abc\0".as_ptr() as *const i8
-        )) > (0))
-    );
-    let mut p: *const u8 = b"FOO\0".as_ptr();
-    let mut q: *const u8 = b"foo\0".as_ptr();
-    assert!(((libc::strcasecmp(p as *const i8, q as *const i8)) == (0)));
+    assert!(((libc::strcasecmp(c"HELLO".as_ptr(), c"hello".as_ptr())) == (0)));
+    assert!(((libc::strcasecmp(c"abc".as_ptr(), c"abd".as_ptr())) < (0)));
+    assert!(((libc::strcasecmp(c"abd".as_ptr(), c"abc".as_ptr())) > (0)));
+    let mut p: *const libc::c_char = c"FOO".as_ptr();
+    let mut q: *const libc::c_char = c"foo".as_ptr();
+    assert!(((libc::strcasecmp(p, q)) == (0)));
 }
 pub fn main() {
     unsafe {
diff --git a/tests/unit/out/unsafe/default_in_statics.rs b/tests/unit/out/unsafe/default_in_statics.rs
index 4694da33..3ef0e18b 100644
--- a/tests/unit/out/unsafe/default_in_statics.rs
+++ b/tests/unit/out/unsafe/default_in_statics.rs
@@ -10,7 +10,7 @@ use std::rc::Rc;
 #[derive(Copy, Clone, Default)]
 pub struct Inner {
     pub v: i32,
-    pub name: *const u8,
+    pub name: *const libc::c_char,
 }
 #[repr(C)]
 #[derive(Copy, Clone)]
@@ -18,7 +18,7 @@ pub struct Outer {
     pub p1: *mut i32,
     pub p2: *const i32,
     pub arr: [*mut i32; 3],
-    pub cp: *const u8,
+    pub cp: *const libc::c_char,
     pub pp: *mut *mut i32,
     pub inner: Inner,
     pub x: i32,
@@ -41,8 +41,8 @@ impl Default for Outer {
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub struct Foo {
-    pub s1: *const u8,
-    pub s2: *const u8,
+    pub s1: *const libc::c_char,
+    pub s2: *const libc::c_char,
     pub fn1: Option<unsafe fn(i32) -> i32>,
     pub fn2: Option<unsafe fn(i32) -> i32>,
     pub n: i32,
@@ -82,7 +82,7 @@ pub static mut static_inner_array_2: [Inner; 2] = unsafe {
 };
 pub static mut static_foo_3: Foo = unsafe {
     Foo {
-        s1: b"hello\0".as_ptr(),
+        s1: c"hello".as_ptr(),
         s2: std::ptr::null(),
         fn1: None,
         fn2: None,
@@ -92,14 +92,14 @@ pub static mut static_foo_3: Foo = unsafe {
 pub static mut static_foo_array_4: [Foo; 2] = unsafe {
     [
         Foo {
-            s1: b"first\0".as_ptr(),
+            s1: c"first".as_ptr(),
             s2: std::ptr::null(),
             fn1: None,
             fn2: None,
             n: 1,
         },
         Foo {
-            s1: b"second\0".as_ptr(),
+            s1: c"second".as_ptr(),
             s2: std::ptr::null(),
             fn1: None,
             fn2: None,
diff --git a/tests/unit/out/unsafe/empty_main.rs b/tests/unit/out/unsafe/empty_main.rs
index 97b40abf..c92775cf 100644
--- a/tests/unit/out/unsafe/empty_main.rs
+++ b/tests/unit/out/unsafe/empty_main.rs
@@ -12,10 +12,13 @@ pub fn main() {
         .map(|arg| arg.as_bytes().to_vec())
         .collect();
     args.iter_mut().for_each(|v| v.push(0));
-    let mut argv: Vec<*mut u8> = args.iter().map(|arg| arg.as_ptr() as *mut u8).collect();
+    let mut argv: Vec<*mut libc::c_char> = args
+        .iter()
+        .map(|arg| arg.as_ptr() as *mut libc::c_char)
+        .collect();
     argv.push(::std::ptr::null_mut());
     unsafe { ::std::process::exit(main_0((argv.len() - 1) as i32, argv.as_mut_ptr()) as i32) }
 }
-unsafe fn main_0(_: i32, _: *mut *mut u8) -> i32 {
+unsafe fn main_0(_: i32, _: *mut *mut libc::c_char) -> i32 {
     return 0;
 }
diff --git a/tests/unit/out/unsafe/enum_int_interop.rs b/tests/unit/out/unsafe/enum_int_interop.rs
index 5f0b57be..7c417654 100644
--- a/tests/unit/out/unsafe/enum_int_interop.rs
+++ b/tests/unit/out/unsafe/enum_int_interop.rs
@@ -65,7 +65,7 @@ libcc2rs::impl_enum_inc_dec!(Tag);
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Entry {
-    pub name: *const u8,
+    pub name: *const libc::c_char,
     pub color: Color,
     pub opt: Option,
 }
@@ -75,17 +75,17 @@ pub static mut global_tag_2: Tag = unsafe { Tag::TAG_TWO };
 pub static mut entries_3: [Entry; 3] = unsafe {
     [
         Entry {
-            name: b"first\0".as_ptr(),
+            name: c"first".as_ptr(),
             color: Color::RED,
             opt: Option::OPT_NONE,
         },
         Entry {
-            name: b"second\0".as_ptr(),
+            name: c"second".as_ptr(),
             color: Color::GREEN,
             opt: Option::OPT_A,
         },
         Entry {
-            name: b"third\0".as_ptr(),
+            name: c"third".as_ptr(),
             color: Color::BLUE,
             opt: Option::OPT_C,
         },
diff --git a/tests/unit/out/unsafe/enum_int_interop_c.rs b/tests/unit/out/unsafe/enum_int_interop_c.rs
index ceb08390..e4fa3dd0 100644
--- a/tests/unit/out/unsafe/enum_int_interop_c.rs
+++ b/tests/unit/out/unsafe/enum_int_interop_c.rs
@@ -65,7 +65,7 @@ libcc2rs::impl_enum_inc_dec!(Tag_enum);
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Entry {
-    pub name: *const u8,
+    pub name: *const libc::c_char,
     pub color: Color,
     pub opt: Option,
 }
@@ -75,17 +75,17 @@ pub static mut global_tag_2: Tag_enum = unsafe { Tag_enum::TAG_TWO };
 pub static mut entries_3: [Entry; 3] = unsafe {
     [
         Entry {
-            name: (b"first\0".as_ptr().cast_mut()).cast_const(),
+            name: (c"first".as_ptr().cast_mut()).cast_const(),
             color: Color::RED,
             opt: Option::OPT_NONE,
         },
         Entry {
-            name: (b"second\0".as_ptr().cast_mut()).cast_const(),
+            name: (c"second".as_ptr().cast_mut()).cast_const(),
             color: Color::GREEN,
             opt: Option::OPT_A,
         },
         Entry {
-            name: (b"third\0".as_ptr().cast_mut()).cast_const(),
+            name: (c"third".as_ptr().cast_mut()).cast_const(),
             color: Color::BLUE,
             opt: Option::OPT_C,
         },
diff --git a/tests/unit/out/unsafe/errno.rs b/tests/unit/out/unsafe/errno.rs
index ccf75e07..5a5e67a0 100644
--- a/tests/unit/out/unsafe/errno.rs
+++ b/tests/unit/out/unsafe/errno.rs
@@ -17,10 +17,11 @@ pub unsafe fn test_errno_0() {
 }
 pub unsafe fn test_errno_preserved_across_strdup_1() {
     (*libcc2rs::cpp2rust_errno()) = 99;
-    let mut d: *mut u8 = libcc2rs::strdup_unsafe((b"hello\0".as_ptr().cast_mut()).cast_const());
+    let mut d: *mut libc::c_char =
+        libcc2rs::strdup_unsafe((c"hello".as_ptr().cast_mut()).cast_const());
     assert!((((!((d).is_null())) as i32) != 0));
     assert!(((((*libcc2rs::cpp2rust_errno()) == (99)) as i32) != 0));
-    libcc2rs::free_unsafe((d as *mut u8 as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void));
     (*libcc2rs::cpp2rust_errno()) = 0;
 }
 pub unsafe fn test_errno_from_fseek_2() {
diff --git a/tests/unit/out/unsafe/expr_as_bool_c.rs b/tests/unit/out/unsafe/expr_as_bool_c.rs
index 0008c059..bad91013 100644
--- a/tests/unit/out/unsafe/expr_as_bool_c.rs
+++ b/tests/unit/out/unsafe/expr_as_bool_c.rs
@@ -9,10 +9,10 @@ use std::rc::Rc;
 pub unsafe fn cmp_eq_0(mut rc: i32) -> i32 {
     return (((rc) == (-1_i32)) as i32);
 }
-pub unsafe fn cmp_or_ptr_1(mut p: *const u8, mut q: *const u8) -> i32 {
+pub unsafe fn cmp_or_ptr_1(mut p: *const libc::c_char, mut q: *const libc::c_char) -> i32 {
     return (((!(p).is_null()) || (!(q).is_null())) as i32);
 }
-pub unsafe fn both_null_2(mut s1: *const u8, mut s2: *const u8) -> i32 {
+pub unsafe fn both_null_2(mut s1: *const libc::c_char, mut s2: *const libc::c_char) -> i32 {
     return ((((((s1).is_null()) as i32) != 0) && ((((s2).is_null()) as i32) != 0)) as i32);
 }
 pub fn main() {
@@ -66,8 +66,8 @@ unsafe fn main_0() -> i32 {
     assert!(((((eq) == (1)) as i32) != 0));
     assert!(((((lt) == (0)) as i32) != 0));
     assert!(((((neq) == (0)) as i32) != 0));
-    let mut p1: *const u8 = (b"hi\0".as_ptr().cast_mut()).cast_const();
-    let mut p2: *const u8 = std::ptr::null();
+    let mut p1: *const libc::c_char = (c"hi".as_ptr().cast_mut()).cast_const();
+    let mut p2: *const libc::c_char = std::ptr::null();
     let mut either: i32 = (((!(p1).is_null()) || (!(p2).is_null())) as i32);
     let mut both: i32 = (((!(p1).is_null()) && (!(p2).is_null())) as i32);
     assert!(((((either) == (1)) as i32) != 0));
diff --git a/tests/unit/out/unsafe/expr_as_bool_cpp.rs b/tests/unit/out/unsafe/expr_as_bool_cpp.rs
index ee521d50..a5381910 100644
--- a/tests/unit/out/unsafe/expr_as_bool_cpp.rs
+++ b/tests/unit/out/unsafe/expr_as_bool_cpp.rs
@@ -9,10 +9,10 @@ use std::rc::Rc;
 pub unsafe fn cmp_eq_0(mut rc: i32) -> i32 {
     return (((rc) == (-1_i32)) as i32);
 }
-pub unsafe fn cmp_or_ptr_1(mut p: *const u8, mut q: *const u8) -> i32 {
+pub unsafe fn cmp_or_ptr_1(mut p: *const libc::c_char, mut q: *const libc::c_char) -> i32 {
     return (((!(p).is_null()) || (!(q).is_null())) as i32);
 }
-pub unsafe fn both_null_2(mut s1: *const u8, mut s2: *const u8) -> i32 {
+pub unsafe fn both_null_2(mut s1: *const libc::c_char, mut s2: *const libc::c_char) -> i32 {
     return ((((s1).is_null()) && ((s2).is_null())) as i32);
 }
 pub fn main() {
@@ -63,8 +63,8 @@ unsafe fn main_0() -> i32 {
     assert!(((eq) == (1)));
     assert!(((lt) == (0)));
     assert!(((neq) == (0)));
-    let mut p1: *const u8 = b"hi\0".as_ptr();
-    let mut p2: *const u8 = std::ptr::null();
+    let mut p1: *const libc::c_char = c"hi".as_ptr();
+    let mut p2: *const libc::c_char = std::ptr::null();
     let mut either: i32 = (((!(p1).is_null()) || (!(p2).is_null())) as i32);
     let mut both: i32 = (((!(p1).is_null()) && (!(p2).is_null())) as i32);
     assert!(((either) == (1)));
diff --git a/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs b/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs
index 08046da6..f4601563 100644
--- a/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs
+++ b/tests/unit/out/unsafe/fn_ptr_stdlib_compare.rs
@@ -7,7 +7,7 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn my_alternative_fread_0(
-    mut p: *mut u8,
+    mut p: *mut libc::c_char,
     mut n: usize,
     mut m: usize,
     mut f: *mut ::libc::c_void,
@@ -15,7 +15,7 @@ pub unsafe fn my_alternative_fread_0(
     return 22_usize;
 }
 pub unsafe fn my_alternative_fwrite_1(
-    mut p: *const u8,
+    mut p: *const libc::c_char,
     mut n: usize,
     mut m: usize,
     mut f: *mut ::libc::c_void,
@@ -32,21 +32,21 @@ unsafe fn main_0() -> i32 {
         Some(libcc2rs::fread_unsafe);
     assert!(((fn1) == (Some(libcc2rs::fread_unsafe))));
     assert!(!((fn1).is_none()));
-    let mut fn2: Option<unsafe fn(*mut u8, usize, usize, *mut ::libc::c_void) -> usize> =
+    let mut fn2: Option<unsafe fn(*mut libc::c_char, usize, usize, *mut ::libc::c_void) -> usize> =
         std::mem::transmute::<
             Option<unsafe fn(*mut ::libc::c_void, usize, usize, *mut ::libc::FILE) -> usize>,
-            Option<unsafe fn(*mut u8, usize, usize, *mut ::libc::c_void) -> usize>,
+            Option<unsafe fn(*mut libc::c_char, usize, usize, *mut ::libc::c_void) -> usize>,
         >(Some(libcc2rs::fread_unsafe));
     assert!(
         ((fn1)
             == (std::mem::transmute::<
-                Option<unsafe fn(*mut u8, usize, usize, *mut ::libc::c_void) -> usize>,
+                Option<unsafe fn(*mut libc::c_char, usize, usize, *mut ::libc::c_void) -> usize>,
                 Option<unsafe fn(*mut ::libc::c_void, usize, usize, *mut ::libc::FILE) -> usize>,
             >(fn2)))
     );
     let mut f3: Option<unsafe fn(*mut ::libc::c_void, usize, usize, *mut ::libc::FILE) -> usize> =
         std::mem::transmute::<
-            Option<unsafe fn(*mut u8, usize, usize, *mut ::libc::c_void) -> usize>,
+            Option<unsafe fn(*mut libc::c_char, usize, usize, *mut ::libc::c_void) -> usize>,
             Option<unsafe fn(*mut ::libc::c_void, usize, usize, *mut ::libc::FILE) -> usize>,
         >(Some(my_alternative_fread_0));
     assert!(
@@ -56,21 +56,18 @@ unsafe fn main_0() -> i32 {
     let mut __do_while = true;
     'loop_: while __do_while || (0 != 0) {
         __do_while = false;
-        let mut stream: *mut ::libc::FILE = libc::fopen(
-            b"/dev/zero\0".as_ptr() as *const i8,
-            b"rb\0".as_ptr() as *const i8,
-        );
+        let mut stream: *mut ::libc::FILE = libc::fopen(c"/dev/zero".as_ptr(), c"rb".as_ptr());
         assert!(!((stream).is_null()));
-        let mut buf: [u8; 16] = [0_u8; 16];
+        let mut buf: [libc::c_char; 16] = [(0 as libc::c_char); 16];
         {
-            let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
-            for offset in 0..::std::mem::size_of::<[u8; 16]>() {
-                *byte_0.offset(offset as isize) = (('X' as u8) as i32) as u8;
+            let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8;
+            for offset in 0..::std::mem::size_of::<[libc::c_char; 16]>() {
+                *byte_0.offset(offset as isize) = (('X' as libc::c_char) as i32) as u8;
             }
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
         };
         let mut n: usize = libcc2rs::fread_unsafe(
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
             1_usize,
             10_usize,
             stream,
@@ -83,7 +80,7 @@ unsafe fn main_0() -> i32 {
         }
         let mut i: i32 = 10;
         'loop_: while ((i) < (16)) {
-            assert!(((buf[(i) as usize] as i32) == (('X' as u8) as i32)));
+            assert!(((buf[(i) as usize] as i32) == (('X' as libc::c_char) as i32)));
             i.prefix_inc();
         }
         libc::fclose(stream);
@@ -91,22 +88,19 @@ unsafe fn main_0() -> i32 {
     let mut __do_while = true;
     'loop_: while __do_while || (0 != 0) {
         __do_while = false;
-        let mut stream: *mut ::libc::FILE = libc::fopen(
-            b"/dev/zero\0".as_ptr() as *const i8,
-            b"rb\0".as_ptr() as *const i8,
-        );
+        let mut stream: *mut ::libc::FILE = libc::fopen(c"/dev/zero".as_ptr(), c"rb".as_ptr());
         assert!(!((stream).is_null()));
-        let mut buf: [u8; 16] = [0_u8; 16];
+        let mut buf: [libc::c_char; 16] = [(0 as libc::c_char); 16];
         {
-            let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
-            for offset in 0..::std::mem::size_of::<[u8; 16]>() {
-                *byte_0.offset(offset as isize) = (('X' as u8) as i32) as u8;
+            let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8;
+            for offset in 0..::std::mem::size_of::<[libc::c_char; 16]>() {
+                *byte_0.offset(offset as isize) = (('X' as libc::c_char) as i32) as u8;
             }
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
         };
         let mut n: usize = (unsafe {
             (fn1).unwrap()(
-                (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+                (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
                 1_usize,
                 10_usize,
                 stream,
@@ -120,7 +114,7 @@ unsafe fn main_0() -> i32 {
         }
         let mut i: i32 = 10;
         'loop_: while ((i) < (16)) {
-            assert!(((buf[(i) as usize] as i32) == (('X' as u8) as i32)));
+            assert!(((buf[(i) as usize] as i32) == (('X' as libc::c_char) as i32)));
             i.prefix_inc();
         }
         libc::fclose(stream);
@@ -130,21 +124,22 @@ unsafe fn main_0() -> i32 {
     > = Some(libcc2rs::fwrite_unsafe);
     assert!(((gn1) == (Some(libcc2rs::fwrite_unsafe))));
     assert!(!((gn1).is_none()));
-    let mut gn2: Option<unsafe fn(*const u8, usize, usize, *mut ::libc::c_void) -> usize> =
-        std::mem::transmute::<
-            Option<unsafe fn(*const ::libc::c_void, usize, usize, *mut ::libc::FILE) -> usize>,
-            Option<unsafe fn(*const u8, usize, usize, *mut ::libc::c_void) -> usize>,
-        >(Some(libcc2rs::fwrite_unsafe));
+    let mut gn2: Option<
+        unsafe fn(*const libc::c_char, usize, usize, *mut ::libc::c_void) -> usize,
+    > = std::mem::transmute::<
+        Option<unsafe fn(*const ::libc::c_void, usize, usize, *mut ::libc::FILE) -> usize>,
+        Option<unsafe fn(*const libc::c_char, usize, usize, *mut ::libc::c_void) -> usize>,
+    >(Some(libcc2rs::fwrite_unsafe));
     assert!(
         ((gn1)
             == (std::mem::transmute::<
-                Option<unsafe fn(*const u8, usize, usize, *mut ::libc::c_void) -> usize>,
+                Option<unsafe fn(*const libc::c_char, usize, usize, *mut ::libc::c_void) -> usize>,
                 Option<unsafe fn(*const ::libc::c_void, usize, usize, *mut ::libc::FILE) -> usize>,
             >(gn2)))
     );
     let mut g3: Option<unsafe fn(*const ::libc::c_void, usize, usize, *mut ::libc::FILE) -> usize> =
         std::mem::transmute::<
-            Option<unsafe fn(*const u8, usize, usize, *mut ::libc::c_void) -> usize>,
+            Option<unsafe fn(*const libc::c_char, usize, usize, *mut ::libc::c_void) -> usize>,
             Option<unsafe fn(*const ::libc::c_void, usize, usize, *mut ::libc::FILE) -> usize>,
         >(Some(my_alternative_fwrite_1));
     assert!(
@@ -154,21 +149,18 @@ unsafe fn main_0() -> i32 {
     let mut __do_while = true;
     'loop_: while __do_while || (0 != 0) {
         __do_while = false;
-        let mut stream: *mut ::libc::FILE = libc::fopen(
-            b"/dev/null\0".as_ptr() as *const i8,
-            b"wb\0".as_ptr() as *const i8,
-        );
+        let mut stream: *mut ::libc::FILE = libc::fopen(c"/dev/null".as_ptr(), c"wb".as_ptr());
         assert!(!((stream).is_null()));
-        let mut buf: [u8; 10] = [0_u8; 10];
+        let mut buf: [libc::c_char; 10] = [(0 as libc::c_char); 10];
         {
-            let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
-            for offset in 0..::std::mem::size_of::<[u8; 10]>() {
-                *byte_0.offset(offset as isize) = (('Y' as u8) as i32) as u8;
+            let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8;
+            for offset in 0..::std::mem::size_of::<[libc::c_char; 10]>() {
+                *byte_0.offset(offset as isize) = (('Y' as libc::c_char) as i32) as u8;
             }
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
         };
         let mut n: usize = libcc2rs::fwrite_unsafe(
-            (buf.as_mut_ptr() as *const u8 as *const ::libc::c_void),
+            (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void),
             1_usize,
             10_usize,
             stream,
@@ -179,22 +171,19 @@ unsafe fn main_0() -> i32 {
     let mut __do_while = true;
     'loop_: while __do_while || (0 != 0) {
         __do_while = false;
-        let mut stream: *mut ::libc::FILE = libc::fopen(
-            b"/dev/null\0".as_ptr() as *const i8,
-            b"wb\0".as_ptr() as *const i8,
-        );
+        let mut stream: *mut ::libc::FILE = libc::fopen(c"/dev/null".as_ptr(), c"wb".as_ptr());
         assert!(!((stream).is_null()));
-        let mut buf: [u8; 10] = [0_u8; 10];
+        let mut buf: [libc::c_char; 10] = [(0 as libc::c_char); 10];
         {
-            let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
-            for offset in 0..::std::mem::size_of::<[u8; 10]>() {
-                *byte_0.offset(offset as isize) = (('Y' as u8) as i32) as u8;
+            let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8;
+            for offset in 0..::std::mem::size_of::<[libc::c_char; 10]>() {
+                *byte_0.offset(offset as isize) = (('Y' as libc::c_char) as i32) as u8;
             }
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
         };
         let mut n: usize = (unsafe {
             (gn1).unwrap()(
-                (buf.as_mut_ptr() as *const u8 as *const ::libc::c_void),
+                (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void),
                 1_usize,
                 10_usize,
                 stream,
diff --git a/tests/unit/out/unsafe/fopen.rs b/tests/unit/out/unsafe/fopen.rs
index 93251626..04f91a35 100644
--- a/tests/unit/out/unsafe/fopen.rs
+++ b/tests/unit/out/unsafe/fopen.rs
@@ -12,8 +12,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut fname: *const u8 = b"testfile.txt\0".as_ptr();
-    let mut mode: *const u8 = b"rb\0".as_ptr();
-    let mut file_ptr: *mut ::libc::FILE = libc::fopen(fname as *const i8, mode as *const i8);
+    let mut fname: *const libc::c_char = c"testfile.txt".as_ptr();
+    let mut mode: *const libc::c_char = c"rb".as_ptr();
+    let mut file_ptr: *mut ::libc::FILE = libc::fopen(fname, mode);
     return 0;
 }
diff --git a/tests/unit/out/unsafe/global_pointers.rs b/tests/unit/out/unsafe/global_pointers.rs
index 95ecaa88..a9426e52 100644
--- a/tests/unit/out/unsafe/global_pointers.rs
+++ b/tests/unit/out/unsafe/global_pointers.rs
@@ -9,28 +9,28 @@ use std::rc::Rc;
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct Entry {
-    pub name: *const u8,
+    pub name: *const libc::c_char,
     pub p: *mut i32,
 }
 pub static mut single_entry_0: Entry = unsafe {
     Entry {
-        name: b"alone\0".as_ptr(),
+        name: c"alone".as_ptr(),
         p: std::ptr::null_mut(),
     }
 };
 pub static mut entries_1: [Entry; 2] = unsafe {
     [
         Entry {
-            name: b"first\0".as_ptr(),
+            name: c"first".as_ptr(),
             p: std::ptr::null_mut(),
         },
         Entry {
-            name: b"second\0".as_ptr(),
+            name: c"second".as_ptr(),
             p: std::ptr::null_mut(),
         },
     ]
 };
-pub static mut arr_of_pointers_2: [*mut u8; 3] = unsafe {
+pub static mut arr_of_pointers_2: [*mut libc::c_char; 3] = unsafe {
     [
         std::ptr::null_mut(),
         std::ptr::null_mut(),
diff --git a/tests/unit/out/unsafe/goto_aggregate_default.rs b/tests/unit/out/unsafe/goto_aggregate_default.rs
index 0f9638e8..bb1719d3 100644
--- a/tests/unit/out/unsafe/goto_aggregate_default.rs
+++ b/tests/unit/out/unsafe/goto_aggregate_default.rs
@@ -13,7 +13,7 @@ pub struct Point {
     pub y: i32,
 }
 pub unsafe fn agg_0(mut n: i32) -> i32 {
-    let mut buf40: [u8; 40] = [0_u8; 40];
+    let mut buf40: [libc::c_char; 40] = [(0 as libc::c_char); 40];
     let mut buf256: [u8; 256] = [0_u8; 256];
     let mut arr64: [i32; 64] = [0_i32; 64];
     let mut longs: [i64; 33] = [0_i64; 33];
diff --git a/tests/unit/out/unsafe/huffman.rs b/tests/unit/out/unsafe/huffman.rs
index cad1c109..985abed9 100644
--- a/tests/unit/out/unsafe/huffman.rs
+++ b/tests/unit/out/unsafe/huffman.rs
@@ -9,7 +9,7 @@ use std::rc::Rc;
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct MinHeapNode {
-    pub data: u8,
+    pub data: libc::c_char,
     pub freq: i32,
     pub left: *mut MinHeapNode,
     pub right: *mut MinHeapNode,
@@ -51,7 +51,7 @@ pub struct MinHeap {
     pub alloc: Option<Box<[MinHeapNode]>>,
 }
 impl MinHeap {
-    pub unsafe fn Alloc(&mut self, mut data: u8, mut freq: i32) -> *mut MinHeapNode {
+    pub unsafe fn Alloc(&mut self, mut data: libc::c_char, mut freq: i32) -> *mut MinHeapNode {
         self.alloc.as_mut().unwrap()[(self.next as usize)] = MinHeapNode {
             data: data,
             freq: freq,
@@ -110,14 +110,14 @@ impl MinHeap {
     }
     pub unsafe fn Build(
         &mut self,
-        data: *mut Option<Box<[u8]>>,
+        data: *mut Option<Box<[libc::c_char]>>,
         freq: *mut Option<Box<[i32]>>,
         mut n: i32,
     ) {
         let mut i: i32 = 0;
         'loop_: while ((i) < (n)) {
             self.arr.as_mut().unwrap()[(self.size.postfix_inc() as usize)] = (unsafe {
-                let _data: u8 = (*data).as_mut().unwrap()[(i as usize)];
+                let _data: libc::c_char = (*data).as_mut().unwrap()[(i as usize)];
                 let _freq: i32 = (*freq).as_mut().unwrap()[(i as usize)];
                 self.Alloc(_data, _freq)
             });
@@ -149,13 +149,13 @@ pub unsafe fn AllocMinHeap_1(mut capacity: i32) -> Option<Box<MinHeap>> {
     return minHeap;
 }
 pub unsafe fn Huffman_2(
-    data: *mut Option<Box<[u8]>>,
+    data: *mut Option<Box<[libc::c_char]>>,
     freq: *mut Option<Box<[i32]>>,
     mut size: i32,
 ) -> Option<Box<MinHeap>> {
     let mut minHeap: Option<Box<MinHeap>> = (unsafe { AllocMinHeap_1(size) });
     (unsafe {
-        let _data: *mut Option<Box<[u8]>> = data;
+        let _data: *mut Option<Box<[libc::c_char]>> = data;
         let _freq: *mut Option<Box<[i32]>> = freq;
         let _n: i32 = size;
         (*minHeap.as_deref_mut().unwrap()).Build(_data, _freq, _n)
@@ -167,7 +167,7 @@ pub unsafe fn Huffman_2(
             (unsafe { (*minHeap.as_deref_mut().unwrap()).ExtractMin() });
         let mut top: *mut MinHeapNode = (unsafe {
             (*minHeap.as_deref_mut().unwrap())
-                .Alloc(('$' as u8), (((*left).freq) + ((*right).freq)))
+                .Alloc(('$' as libc::c_char), (((*left).freq) + ((*right).freq)))
         });
         (*top).left = left;
         (*top).right = right;
@@ -233,12 +233,12 @@ pub unsafe fn CollectCodes_4(
     }
 }
 pub unsafe fn HuffmanCodes_5(
-    data: *mut Option<Box<[u8]>>,
+    data: *mut Option<Box<[libc::c_char]>>,
     freq: *mut Option<Box<[i32]>>,
     mut size: i32,
 ) -> Option<Box<[i32]>> {
     let mut minHeap: Option<Box<MinHeap>> = (unsafe {
-        let _data: *mut Option<Box<[u8]>> = data;
+        let _data: *mut Option<Box<[libc::c_char]>> = data;
         let _freq: *mut Option<Box<[i32]>> = freq;
         let _size: i32 = size;
         Huffman_2(_data, _freq, _size)
@@ -274,18 +274,18 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     let mut size: i32 = 6;
-    let mut arr1: [u8; 6] = [
-        ('a' as u8),
-        ('b' as u8),
-        ('c' as u8),
-        ('d' as u8),
-        ('e' as u8),
-        ('f' as u8),
+    let mut arr1: [libc::c_char; 6] = [
+        ('a' as libc::c_char),
+        ('b' as libc::c_char),
+        ('c' as libc::c_char),
+        ('d' as libc::c_char),
+        ('e' as libc::c_char),
+        ('f' as libc::c_char),
     ];
     let mut arr2: [i32; 6] = [5, 9, 12, 13, 16, 45];
-    let mut data: Option<Box<[u8]>> = Some(
+    let mut data: Option<Box<[libc::c_char]>> = Some(
         (0..(size as usize))
-            .map(|_| <u8>::default())
+            .map(|_| <libc::c_char>::default())
             .collect::<Box<[_]>>(),
     );
     let mut freq: Option<Box<[i32]>> = Some(
@@ -301,7 +301,7 @@ unsafe fn main_0() -> i32 {
     }
     let mut out: Option<Box<[i32]>> = (unsafe {
         HuffmanCodes_5(
-            &mut data as *mut Option<Box<[u8]>>,
+            &mut data as *mut Option<Box<[libc::c_char]>>,
             &mut freq as *mut Option<Box<[i32]>>,
             size,
         )
diff --git a/tests/unit/out/unsafe/iterators.rs b/tests/unit/out/unsafe/iterators.rs
index a17f26ef..71256cef 100644
--- a/tests/unit/out/unsafe/iterators.rs
+++ b/tests/unit/out/unsafe/iterators.rs
@@ -12,8 +12,8 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut x: Vec<u8> = {
-        let s = b"hello\0".as_ptr();
+    let mut x: Vec<libc::c_char> = {
+        let s = c"hello".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
     'loop_: for c in 0..(x.len() - 1) {
@@ -22,18 +22,18 @@ unsafe fn main_0() -> i32 {
     }
     'loop_: for c in 0..(x.len() - 1) {
         let mut c = x.as_mut_ptr().add(c);
-        printf(b"%c\n\0".as_ptr() as *const i8, ((*c) as i32));
+        printf(c"%c\n".as_ptr() as *const i8, ((*c) as i32));
     }
     'loop_: for c in 0..(x.len() - 1) {
         let mut c = x[c].clone();
-        printf(b"%c\n\0".as_ptr() as *const i8, (c as i32));
+        printf(c"%c\n".as_ptr() as *const i8, (c as i32));
     }
     let mut v: Vec<*mut i32> = Vec::new();
     v.push((Box::leak(Box::new(2)) as *mut i32));
     v.push((Box::leak(Box::new(3)) as *mut i32));
     'loop_: for p in 0..(v.len()) {
         let mut p = v[p].clone();
-        printf(b"%d\n\0".as_ptr() as *const i8, (*p));
+        printf(c"%d\n".as_ptr() as *const i8, (*p));
     }
     return 0;
 }
diff --git a/tests/unit/out/unsafe/libc_char_ptr_field.rs b/tests/unit/out/unsafe/libc_char_ptr_field.rs
index 9018c046..603e3730 100644
--- a/tests/unit/out/unsafe/libc_char_ptr_field.rs
+++ b/tests/unit/out/unsafe/libc_char_ptr_field.rs
@@ -16,10 +16,9 @@ unsafe fn main_0() -> i32 {
     if !!(pw).is_null() {
         return 0;
     }
-    let mut home: *mut u8 = ((*pw).pw_dir as *mut u8);
-    let mut d: *mut dirent = libc::readdir(libc::opendir(
-        (b"/tmp\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    ));
-    let mut dname: *mut u8 = ((*d).d_name.as_mut_ptr() as *mut u8);
+    let mut home: *mut libc::c_char = (*pw).pw_dir;
+    let mut d: *mut dirent =
+        libc::readdir(libc::opendir((c"/tmp".as_ptr().cast_mut()).cast_const()));
+    let mut dname: *mut libc::c_char = (*d).d_name.as_mut_ptr();
     return 0;
 }
diff --git a/tests/unit/out/unsafe/macros.rs b/tests/unit/out/unsafe/macros.rs
index 916703d1..4e8d4dbf 100644
--- a/tests/unit/out/unsafe/macros.rs
+++ b/tests/unit/out/unsafe/macros.rs
@@ -6,8 +6,8 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn log_0(mut file: *const u8, mut line: i32, mut func: *const u8) {
-    printf(b"%s %d %s\n\0".as_ptr() as *const i8, file, line, func);
+pub unsafe fn log_0(mut file: *const libc::c_char, mut line: i32, mut func: *const libc::c_char) {
+    printf(c"%s %d %s\n".as_ptr() as *const i8, file, line, func);
 }
 pub fn main() {
     unsafe {
@@ -16,11 +16,11 @@ pub fn main() {
 }
 unsafe fn main_0() -> i32 {
     printf(
-        b"%s %d %s\n\0".as_ptr() as *const i8,
-        b"macros.cpp\0".as_ptr(),
+        c"%s %d %s\n".as_ptr() as *const i8,
+        c"macros.cpp".as_ptr(),
         8,
-        b"main\0".as_ptr(),
+        c"main".as_ptr(),
     );
-    (unsafe { log_0(b"macros.cpp\0".as_ptr(), 9, b"main\0".as_ptr()) });
+    (unsafe { log_0(c"macros.cpp".as_ptr(), 9, c"main".as_ptr()) });
     return 0;
 }
diff --git a/tests/unit/out/unsafe/main.rs b/tests/unit/out/unsafe/main.rs
index d42b724c..c1932d6a 100644
--- a/tests/unit/out/unsafe/main.rs
+++ b/tests/unit/out/unsafe/main.rs
@@ -12,12 +12,15 @@ pub fn main() {
         .map(|arg| arg.as_bytes().to_vec())
         .collect();
     args.iter_mut().for_each(|v| v.push(0));
-    let mut argv: Vec<*mut u8> = args.iter().map(|arg| arg.as_ptr() as *mut u8).collect();
+    let mut argv: Vec<*mut libc::c_char> = args
+        .iter()
+        .map(|arg| arg.as_ptr() as *mut libc::c_char)
+        .collect();
     argv.push(::std::ptr::null_mut());
     unsafe { ::std::process::exit(main_0((argv.len() - 1) as i32, argv.as_mut_ptr()) as i32) }
 }
-unsafe fn main_0(mut argc: i32, mut argv: *mut *mut u8) -> i32 {
-    let mut s: Vec<u8> = {
+unsafe fn main_0(mut argc: i32, mut argv: *mut *mut libc::c_char) -> i32 {
+    let mut s: Vec<libc::c_char> = {
         let s = (*argv.offset((0) as isize)).cast_const();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
diff --git a/tests/unit/out/unsafe/map-reallocation.rs b/tests/unit/out/unsafe/map-reallocation.rs
index 8b811f12..cb57763f 100644
--- a/tests/unit/out/unsafe/map-reallocation.rs
+++ b/tests/unit/out/unsafe/map-reallocation.rs
@@ -21,11 +21,11 @@ unsafe fn main_0() -> i32 {
     let mut p: *mut i32 = (&mut *it.second() as *mut i32);
     assert!(
         ((*it.second()) == (sentinel))
-            && (!(b"iterator does not have correct value before insert\0".as_ptr()).is_null())
+            && (!(c"iterator does not have correct value before insert".as_ptr()).is_null())
     );
     assert!(
         ((*p) == (sentinel))
-            && (!(b"pointer does not have correct value before insert\0".as_ptr()).is_null())
+            && (!(c"pointer does not have correct value before insert".as_ptr()).is_null())
     );
     let mut i: i32 = 0;
     'loop_: while ((i) < (sentinel)) {
@@ -39,16 +39,16 @@ unsafe fn main_0() -> i32 {
     }
     assert!(
         ((*it.second()) != (0))
-            && (!(b"in refcount, iterator points to index 0 instead of sentinel\0".as_ptr())
+            && (!(c"in refcount, iterator points to index 0 instead of sentinel".as_ptr())
                 .is_null())
     );
     assert!(
         ((*it.second()) == (sentinel))
-            && (!(b"iterator does not have correct value after insert\0".as_ptr()).is_null())
+            && (!(c"iterator does not have correct value after insert".as_ptr()).is_null())
     );
     assert!(
         ((*p) == (sentinel))
-            && (!(b"pointer does not have correct value after insert\0".as_ptr()).is_null())
+            && (!(c"pointer does not have correct value after insert".as_ptr()).is_null())
     );
     *it.second() = 57005;
     assert!(((*m.entry(sentinel).or_default().as_mut()) == (57005)));
diff --git a/tests/unit/out/unsafe/null_in_statics.rs b/tests/unit/out/unsafe/null_in_statics.rs
index c44051ee..2c26d414 100644
--- a/tests/unit/out/unsafe/null_in_statics.rs
+++ b/tests/unit/out/unsafe/null_in_statics.rs
@@ -8,11 +8,11 @@ use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub static mut p_mut_0: *mut i32 = unsafe { std::ptr::null_mut() };
 pub static mut p_const_1: *const i32 = unsafe { std::ptr::null() };
-pub static mut cp_2: *const u8 = unsafe { std::ptr::null() };
+pub static mut cp_2: *const libc::c_char = unsafe { std::ptr::null() };
 pub static mut arr_of_ptr_3: [*mut i32; 4] = unsafe { [std::ptr::null_mut(); 4] };
 pub static mut pp_4: *mut *mut i32 = unsafe { std::ptr::null_mut() };
 pub static mut const_arr_of_ptr_5: [*const i32; 3] = unsafe { [std::ptr::null(); 3] };
-pub static mut cp_explicit_null_6: *const u8 = unsafe { std::ptr::null() };
+pub static mut cp_explicit_null_6: *const libc::c_char = unsafe { std::ptr::null() };
 pub static mut p_zero_7: *mut i32 = unsafe { std::ptr::null_mut() };
 pub fn main() {
     unsafe {
diff --git a/tests/unit/out/unsafe/pointer_printf.rs b/tests/unit/out/unsafe/pointer_printf.rs
index 151a86e8..70a232cc 100644
--- a/tests/unit/out/unsafe/pointer_printf.rs
+++ b/tests/unit/out/unsafe/pointer_printf.rs
@@ -14,6 +14,6 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut a: i32 = 1;
     let mut p: *mut i32 = (&mut a as *mut i32);
-    printf(b"%p %d\0".as_ptr() as *const i8, p, (*p));
+    printf(c"%p %d".as_ptr() as *const i8, p, (*p));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/printfs.rs b/tests/unit/out/unsafe/printfs.rs
index b866d93c..636b5163 100644
--- a/tests/unit/out/unsafe/printfs.rs
+++ b/tests/unit/out/unsafe/printfs.rs
@@ -6,11 +6,11 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn fn_0(mut v: Vec<u8>) -> Vec<u8> {
+pub unsafe fn fn_0(mut v: Vec<libc::c_char>) -> Vec<libc::c_char> {
     return {
         let mut __tmp2 = v.clone();
         __tmp2.pop();
-        let __from = b" str\0".as_ptr();
+        let __from = c" str".as_ptr();
         __tmp2.extend_from_slice(::std::slice::from_raw_parts(
             __from,
             (0..).position(|i| *__from.add(i) == 0).unwrap(),
@@ -19,7 +19,7 @@ pub unsafe fn fn_0(mut v: Vec<u8>) -> Vec<u8> {
         __tmp2
     };
 }
-pub unsafe fn fn2_1(v: *const Vec<u8>) -> *const Vec<u8> {
+pub unsafe fn fn2_1(v: *const Vec<libc::c_char>) -> *const Vec<libc::c_char> {
     return v;
 }
 pub fn main() {
@@ -28,26 +28,23 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    printf(
-        b"%s\n\0".as_ptr() as *const i8,
-        b"fprintf stdout\0".as_ptr(),
-    );
-    printf(b"%d %u %ld\n\0".as_ptr() as *const i8, 1, 2_u32, 3_i64);
-    printf(b"hello world\0".as_ptr() as *const i8);
+    printf(c"%s\n".as_ptr() as *const i8, c"fprintf stdout".as_ptr());
+    printf(c"%d %u %ld\n".as_ptr() as *const i8, 1, 2_u32, 3_i64);
+    printf(c"hello world".as_ptr() as *const i8);
     let mut in_: *mut ::libc::FILE = libcc2rs::stdin_unsafe();
     assert!(!((in_).is_null()));
-    printf(b"%s\n\0".as_ptr() as *const i8, b"printf\0".as_ptr());
-    printf(b"hello world\0".as_ptr() as *const i8);
-    let mut s: Vec<u8> = {
-        let s = b"a string\0".as_ptr();
+    printf(c"%s\n".as_ptr() as *const i8, c"printf".as_ptr());
+    printf(c"hello world".as_ptr() as *const i8);
+    let mut s: Vec<libc::c_char> = {
+        let s = c"a string".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
-    printf(b"%s\n\0".as_ptr() as *const i8, s.as_mut_ptr());
+    printf(c"%s\n".as_ptr() as *const i8, s.as_mut_ptr());
     printf(
-        b"%s\n\0".as_ptr() as *const i8,
+        c"%s\n".as_ptr() as *const i8,
         (unsafe {
             fn_0({
-                let s = b"foo\0".as_ptr();
+                let s = c"foo".as_ptr();
                 std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
                     .to_vec()
             })
@@ -55,8 +52,8 @@ unsafe fn main_0() -> i32 {
         .as_ptr(),
     );
     printf(
-        b"%s\n\0".as_ptr() as *const i8,
-        (*(unsafe { fn2_1(&s as *const Vec<u8>) })).as_ptr(),
+        c"%s\n".as_ptr() as *const i8,
+        (*(unsafe { fn2_1(&s as *const Vec<libc::c_char>) })).as_ptr(),
     );
     return 0;
 }
diff --git a/tests/unit/out/unsafe/reinterpret_cast_string.rs b/tests/unit/out/unsafe/reinterpret_cast_string.rs
index d878c6ac..0910babd 100644
--- a/tests/unit/out/unsafe/reinterpret_cast_string.rs
+++ b/tests/unit/out/unsafe/reinterpret_cast_string.rs
@@ -12,15 +12,15 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut s: Vec<u8> = {
-        let s = b"ABCD\0".as_ptr();
+    let mut s: Vec<libc::c_char> = {
+        let s = c"ABCD".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
     let mut bytes: *const u8 = (s.as_ptr() as *const u8);
-    assert!((((*bytes.offset((0) as isize)) as i32) == (('A' as u8) as i32)));
-    assert!((((*bytes.offset((1) as isize)) as i32) == (('B' as u8) as i32)));
-    assert!((((*bytes.offset((2) as isize)) as i32) == (('C' as u8) as i32)));
-    assert!((((*bytes.offset((3) as isize)) as i32) == (('D' as u8) as i32)));
+    assert!((((*bytes.offset((0) as isize)) as i32) == (('A' as libc::c_char) as i32)));
+    assert!((((*bytes.offset((1) as isize)) as i32) == (('B' as libc::c_char) as i32)));
+    assert!((((*bytes.offset((2) as isize)) as i32) == (('C' as libc::c_char) as i32)));
+    assert!((((*bytes.offset((3) as isize)) as i32) == (('D' as libc::c_char) as i32)));
     assert!((((*bytes.offset((4) as isize)) as i32) == (0)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/stdcopy_ostream.rs b/tests/unit/out/unsafe/stdcopy_ostream.rs
index fe0edeec..17d58f55 100644
--- a/tests/unit/out/unsafe/stdcopy_ostream.rs
+++ b/tests/unit/out/unsafe/stdcopy_ostream.rs
@@ -12,17 +12,14 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut str: Vec<u8> = {
-        let s = b"Hello, world!\n\0".as_ptr();
+    let mut str: Vec<libc::c_char> = {
+        let s = c"Hello, world!\n".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
-    let file: [u8; 25] = *b"test_stdcopy_ostream.txt\0";
-    let mut ofs: ::std::fs::File = ::std::fs::File::create(
-        ::std::ffi::CStr::from_ptr(file.as_ptr() as *const i8)
-            .to_str()
-            .unwrap(),
-    )
-    .unwrap();
+    let file: [libc::c_char; 25] = std::mem::transmute(*b"test_stdcopy_ostream.txt\0");
+    let mut ofs: ::std::fs::File =
+        ::std::fs::File::create(::std::ffi::CStr::from_ptr(file.as_ptr()).to_str().unwrap())
+            .unwrap();
     {
         let __start = str.as_mut_ptr() as *const u8;
         let __end = str.as_mut_ptr().add(str.len() - 1) as *const u8;
@@ -30,6 +27,6 @@ unsafe fn main_0() -> i32 {
         ofs.write_all(::std::slice::from_raw_parts(__start, __len));
         ofs.try_clone().unwrap()
     };
-    libc::unlink(file.as_ptr() as *const i8);
+    libc::unlink(file.as_ptr());
     return 0;
 }
diff --git a/tests/unit/out/unsafe/stdio.rs b/tests/unit/out/unsafe/stdio.rs
index f8cfb849..5bb1469d 100644
--- a/tests/unit/out/unsafe/stdio.rs
+++ b/tests/unit/out/unsafe/stdio.rs
@@ -13,43 +13,38 @@ pub unsafe fn test_fputc_0() {
 }
 pub unsafe fn test_fputs_1() {
     libc::fputs(
-        (b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8,
+        (c"hello".as_ptr().cast_mut()).cast_const(),
         libcc2rs::stdout_unsafe(),
     );
     libc::fputc(('\n' as i32), libcc2rs::stdout_unsafe());
-    let mut s: *const u8 = (b"from variable\0".as_ptr().cast_mut()).cast_const();
-    libc::fputs(s as *const i8, libcc2rs::stdout_unsafe());
+    let mut s: *const libc::c_char = (c"from variable".as_ptr().cast_mut()).cast_const();
+    libc::fputs(s, libcc2rs::stdout_unsafe());
     libc::fputc(('\n' as i32), libcc2rs::stdout_unsafe());
-    let mut buf: [u8; 4] = [
-        (('b' as i32) as u8),
-        (('u' as i32) as u8),
-        (('f' as i32) as u8),
-        (('\0' as i32) as u8),
+    let mut buf: [libc::c_char; 4] = [
+        (('b' as i32) as libc::c_char),
+        (('u' as i32) as libc::c_char),
+        (('f' as i32) as libc::c_char),
+        (('\0' as i32) as libc::c_char),
     ];
-    libc::fputs(
-        (buf.as_mut_ptr()).cast_const() as *const i8,
-        libcc2rs::stdout_unsafe(),
-    );
+    libc::fputs((buf.as_mut_ptr()).cast_const(), libcc2rs::stdout_unsafe());
     libc::fputc(('\n' as i32), libcc2rs::stdout_unsafe());
 }
 pub unsafe fn test_puts_2() {
-    libc::puts((b"puts hello\0".as_ptr().cast_mut()).cast_const() as *const i8);
-    let mut s: *const u8 = (b"puts variable\0".as_ptr().cast_mut()).cast_const();
-    libc::puts(s as *const i8);
+    libc::puts((c"puts hello".as_ptr().cast_mut()).cast_const());
+    let mut s: *const libc::c_char = (c"puts variable".as_ptr().cast_mut()).cast_const();
+    libc::puts(s);
 }
 pub unsafe fn test_fileno_3() {
     assert!(((((libc::fileno(libcc2rs::stdin_unsafe())) == (0)) as i32) != 0));
     assert!(((((libc::fileno(libcc2rs::stdout_unsafe())) == (1)) as i32) != 0));
     assert!(((((libc::fileno(libcc2rs::stderr_unsafe())) == (2)) as i32) != 0));
-    let mut file: *const u8 = (b"/tmp/cpp2rust_fileno_test.tmp\0".as_ptr().cast_mut()).cast_const();
-    let mut fp: *mut ::libc::FILE = libc::fopen(
-        file as *const i8,
-        (b"wb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    let mut file: *const libc::c_char =
+        (c"/tmp/cpp2rust_fileno_test.tmp".as_ptr().cast_mut()).cast_const();
+    let mut fp: *mut ::libc::FILE = libc::fopen(file, (c"wb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
     assert!(((((libc::fileno(fp)) > (2)) as i32) != 0));
     libc::fclose(fp);
-    assert!(((((libc::unlink(file as *const i8)) == (0)) as i32) != 0));
+    assert!(((((libc::unlink(file)) == (0)) as i32) != 0));
 }
 pub fn main() {
     unsafe {
diff --git a/tests/unit/out/unsafe/stdlib_h.rs b/tests/unit/out/unsafe/stdlib_h.rs
index 95df3cdb..2a9d6e03 100644
--- a/tests/unit/out/unsafe/stdlib_h.rs
+++ b/tests/unit/out/unsafe/stdlib_h.rs
@@ -9,42 +9,31 @@ use std::rc::Rc;
 pub unsafe fn test_setenv_getenv_0() {
     assert!(
         ((((libc::setenv(
-            (b"CPP2RUST_TEST_VAR\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"test_value\0".as_ptr().cast_mut()).cast_const() as *const i8,
+            (c"CPP2RUST_TEST_VAR".as_ptr().cast_mut()).cast_const(),
+            (c"test_value".as_ptr().cast_mut()).cast_const(),
             1
         )) == (0)) as i32)
             != 0)
     );
-    let mut v: *const u8 =
-        (libc::getenv((b"CPP2RUST_TEST_VAR\0".as_ptr().cast_mut()).cast_const() as *const i8)
-            as *mut u8)
-            .cast_const();
+    let mut v: *const libc::c_char =
+        (libc::getenv((c"CPP2RUST_TEST_VAR".as_ptr().cast_mut()).cast_const())).cast_const();
     assert!((((!((v).is_null())) as i32) != 0));
     assert!(
-        ((((libc::strcmp(
-            v as *const i8,
-            (b"test_value\0".as_ptr().cast_mut()).cast_const() as *const i8
-        )) == (0)) as i32)
+        ((((libc::strcmp(v, (c"test_value".as_ptr().cast_mut()).cast_const())) == (0)) as i32)
             != 0)
     );
     assert!(
         ((((libc::setenv(
-            (b"CPP2RUST_TEST_VAR\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"replaced\0".as_ptr().cast_mut()).cast_const() as *const i8,
+            (c"CPP2RUST_TEST_VAR".as_ptr().cast_mut()).cast_const(),
+            (c"replaced".as_ptr().cast_mut()).cast_const(),
             1
         )) == (0)) as i32)
             != 0)
     );
-    v = (libc::getenv((b"CPP2RUST_TEST_VAR\0".as_ptr().cast_mut()).cast_const() as *const i8)
-        as *mut u8)
-        .cast_const();
+    v = (libc::getenv((c"CPP2RUST_TEST_VAR".as_ptr().cast_mut()).cast_const())).cast_const();
     assert!((((!((v).is_null())) as i32) != 0));
     assert!(
-        ((((libc::strcmp(
-            v as *const i8,
-            (b"replaced\0".as_ptr().cast_mut()).cast_const() as *const i8
-        )) == (0)) as i32)
-            != 0)
+        ((((libc::strcmp(v, (c"replaced".as_ptr().cast_mut()).cast_const())) == (0)) as i32) != 0)
     );
 }
 pub fn main() {
diff --git a/tests/unit/out/unsafe/string.rs b/tests/unit/out/unsafe/string.rs
index 734c133c..ccff33a8 100644
--- a/tests/unit/out/unsafe/string.rs
+++ b/tests/unit/out/unsafe/string.rs
@@ -12,59 +12,59 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut s1: Vec<u8> = {
-        let s = b"hello\0".as_ptr();
+    let mut s1: Vec<libc::c_char> = {
+        let s = c"hello".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
     assert!(((s1.len() - 1) == (5_usize)));
     assert!(((s1.len() - 1) == (s1.len() - 1)));
-    assert!(((s1[(0_usize)] as i32) == (('h' as u8) as i32)));
-    assert!(((s1[(1_usize)] as i32) == (('e' as u8) as i32)));
-    assert!(((s1[(2_usize)] as i32) == (('l' as u8) as i32)));
-    assert!(((s1[(3_usize)] as i32) == (('l' as u8) as i32)));
-    assert!(((s1[(4_usize)] as i32) == (('o' as u8) as i32)));
+    assert!(((s1[(0_usize)] as i32) == (('h' as libc::c_char) as i32)));
+    assert!(((s1[(1_usize)] as i32) == (('e' as libc::c_char) as i32)));
+    assert!(((s1[(2_usize)] as i32) == (('l' as libc::c_char) as i32)));
+    assert!(((s1[(3_usize)] as i32) == (('l' as libc::c_char) as i32)));
+    assert!(((s1[(4_usize)] as i32) == (('o' as libc::c_char) as i32)));
     assert!(
         s1 == {
-            let s = b"hello\0".as_ptr();
+            let s = c"hello".as_ptr();
             std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
                 .to_vec()
         }
     );
-    let mut p1: *const u8 = (s1.as_mut_ptr()).cast_const();
-    assert!((((*p1.offset((0) as isize)) as i32) == (('h' as u8) as i32)));
-    assert!((((*p1.offset((1) as isize)) as i32) == (('e' as u8) as i32)));
-    assert!((((*p1.offset((2) as isize)) as i32) == (('l' as u8) as i32)));
-    assert!((((*p1.offset((3) as isize)) as i32) == (('l' as u8) as i32)));
-    assert!((((*p1.offset((4) as isize)) as i32) == (('o' as u8) as i32)));
-    let mut s2: Vec<u8> = vec![('a' as u8); (10_usize) as usize]
+    let mut p1: *const libc::c_char = (s1.as_mut_ptr()).cast_const();
+    assert!((((*p1.offset((0) as isize)) as i32) == (('h' as libc::c_char) as i32)));
+    assert!((((*p1.offset((1) as isize)) as i32) == (('e' as libc::c_char) as i32)));
+    assert!((((*p1.offset((2) as isize)) as i32) == (('l' as libc::c_char) as i32)));
+    assert!((((*p1.offset((3) as isize)) as i32) == (('l' as libc::c_char) as i32)));
+    assert!((((*p1.offset((4) as isize)) as i32) == (('o' as libc::c_char) as i32)));
+    let mut s2: Vec<libc::c_char> = vec![('a' as libc::c_char); (10_usize) as usize]
         .iter()
         .cloned()
         .chain(std::iter::once(0))
         .collect();
-    let mut p2: *const u8 = (s2.as_mut_ptr()).cast_const();
+    let mut p2: *const libc::c_char = (s2.as_mut_ptr()).cast_const();
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < (s2.len() - 1)) {
         assert!(
-            (((*p2.offset((i) as isize)) as i32) == (('a' as u8) as i32))
-                && ((s2[(i as usize)] as i32) == (('a' as u8) as i32))
+            (((*p2.offset((i) as isize)) as i32) == (('a' as libc::c_char) as i32))
+                && ((s2[(i as usize)] as i32) == (('a' as libc::c_char) as i32))
         );
         i.prefix_inc();
     }
     assert!(((s2.len() - 1) == (10_usize)));
     assert!(((s2.len() - 1) == (s2.len() - 1)));
-    s2[(0_usize)] = ('b' as u8);
-    s2[(1_usize)] = ('c' as u8);
-    assert!(((s2[(0_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((s2[(1_usize)] as i32) == (('c' as u8) as i32)));
+    s2[(0_usize)] = ('b' as libc::c_char);
+    s2[(1_usize)] = ('c' as libc::c_char);
+    assert!(((s2[(0_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((s2[(1_usize)] as i32) == (('c' as libc::c_char) as i32)));
     let mut i: u32 = 2_u32;
     'loop_: while ((i as usize) < (s2.len() - 1)) {
         assert!(
-            (((*p2.offset((i) as isize)) as i32) == (('a' as u8) as i32))
-                && ((s2[(i as usize)] as i32) == (('a' as u8) as i32))
+            (((*p2.offset((i) as isize)) as i32) == (('a' as libc::c_char) as i32))
+                && ((s2[(i as usize)] as i32) == (('a' as libc::c_char) as i32))
         );
         i.prefix_inc();
     }
-    let mut s3: Vec<u8> = {
+    let mut s3: Vec<libc::c_char> = {
         let mut __tmp1 = s2
             [(2_usize) as usize..::std::cmp::min((2_usize + 5_usize) as usize, s2.len() - 1)]
             .to_vec();
@@ -73,18 +73,18 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((s3.len() - 1) == (5_usize)));
     assert!(((s3.len() - 1) == (s3.len() - 1)));
-    let mut p3: *const u8 = (s3.as_mut_ptr()).cast_const();
+    let mut p3: *const libc::c_char = (s3.as_mut_ptr()).cast_const();
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < (s3.len() - 1)) {
         assert!((((*p3.offset((i) as isize)) as i32) == (s3[(i as usize)] as i32)));
         i.prefix_inc();
     }
-    let mut s4: Vec<u8> = {
+    let mut s4: Vec<libc::c_char> = {
         let mut __tmp1 = s1[(1_usize) as usize
             ..::std::cmp::min(
                 (1_usize
                     + match s1.iter().rposition(|&c| {
-                        ::std::ffi::CStr::from_ptr(b"l\0".as_ptr() as *const i8)
+                        ::std::ffi::CStr::from_ptr(c"l".as_ptr())
                             .to_str()
                             .unwrap()
                             .contains(c as u8 as char)
@@ -100,16 +100,16 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((s4.len() - 1) == (3_usize)));
     assert!(((s4.len() - 1) == (s4.len() - 1)));
-    let mut p4: *const u8 = (s4.as_mut_ptr()).cast_const();
+    let mut p4: *const libc::c_char = (s4.as_mut_ptr()).cast_const();
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < (s4.len() - 1)) {
         assert!((((*p4.offset((i) as isize)) as i32) == (s4[(i as usize)] as i32)));
         i.prefix_inc();
     }
-    let mut s5: Vec<u8> = {
+    let mut s5: Vec<libc::c_char> = {
         let mut __tmp2 = s1.clone();
         __tmp2.pop();
-        let __from = b", world\0".as_ptr();
+        let __from = c", world".as_ptr();
         __tmp2.extend_from_slice(::std::slice::from_raw_parts(
             __from,
             (0..).position(|i| *__from.add(i) == 0).unwrap(),
@@ -119,22 +119,22 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((s5.len() - 1) == (12_usize)));
     assert!(((s5.len() - 1) == (s5.len() - 1)));
-    let mut p5: *const u8 = (s5.as_mut_ptr()).cast_const();
+    let mut p5: *const libc::c_char = (s5.as_mut_ptr()).cast_const();
     let mut i: u32 = 0_u32;
     'loop_: while ((i as usize) < (s5.len() - 1)) {
         assert!((((*p5.offset((i) as isize)) as i32) == (s5[(i as usize)] as i32)));
         i.prefix_inc();
     }
-    let mut arr: [u8; 7] = [
-        ('b' as u8),
-        ('a' as u8),
-        ('r' as u8),
-        (' ' as u8),
-        ('f' as u8),
-        ('o' as u8),
-        ('o' as u8),
+    let mut arr: [libc::c_char; 7] = [
+        ('b' as libc::c_char),
+        ('a' as libc::c_char),
+        ('r' as libc::c_char),
+        (' ' as libc::c_char),
+        ('f' as libc::c_char),
+        ('o' as libc::c_char),
+        ('o' as libc::c_char),
     ];
-    let mut string: Vec<u8> =
+    let mut string: Vec<libc::c_char> =
         std::slice::from_raw_parts((arr.as_mut_ptr()).cast_const(), 3_usize as usize)
             .to_vec()
             .iter()
@@ -142,12 +142,12 @@ unsafe fn main_0() -> i32 {
             .chain(std::iter::once(0))
             .collect();
     assert!(((string.len() - 1) == (3_usize)));
-    assert!(((string[(0_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((string[(1_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((string[(2_usize)] as i32) == (('r' as u8) as i32)));
+    assert!(((string[(0_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((string[(1_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((string[(2_usize)] as i32) == (('r' as libc::c_char) as i32)));
     assert!(
         string == {
-            let s = b"bar\0".as_ptr();
+            let s = c"bar".as_ptr();
             std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
                 .to_vec()
         }
@@ -158,12 +158,12 @@ unsafe fn main_0() -> i32 {
         string.push(0)
     };
     assert!(((string.len() - 1) == (3_usize)));
-    assert!(((string[(0_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((string[(1_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((string[(2_usize)] as i32) == (('r' as u8) as i32)));
+    assert!(((string[(0_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((string[(1_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((string[(2_usize)] as i32) == (('r' as libc::c_char) as i32)));
     assert!(
         string == {
-            let s = b"bar\0".as_ptr();
+            let s = c"bar".as_ptr();
             std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
                 .to_vec()
         }
@@ -174,31 +174,31 @@ unsafe fn main_0() -> i32 {
         string.push(0)
     };
     assert!(((string.len() - 1) == (5_usize)));
-    assert!(((string[(0_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((string[(1_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((string[(2_usize)] as i32) == (('r' as u8) as i32)));
+    assert!(((string[(0_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((string[(1_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((string[(2_usize)] as i32) == (('r' as libc::c_char) as i32)));
     assert!(((string[(3_usize)] as i32) == (0)));
     assert!(((string[(4_usize)] as i32) == (0)));
-    string[(3_usize)] = ('a' as u8);
-    string[(4_usize)] = ('b' as u8);
-    assert!(((string[(3_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((string[(4_usize)] as i32) == (('b' as u8) as i32)));
-    string[(3_usize)] = 0_u8;
-    string[(4_usize)] = 0_u8;
+    string[(3_usize)] = ('a' as libc::c_char);
+    string[(4_usize)] = ('b' as libc::c_char);
+    assert!(((string[(3_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((string[(4_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    string[(3_usize)] = (0 as libc::c_char);
+    string[(4_usize)] = (0 as libc::c_char);
     {
         string.pop();
         string.resize((4_usize) as usize, 0);
         string.push(0)
     };
     assert!(((string.len() - 1) == (4_usize)));
-    assert!(((string[(0_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((string[(1_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((string[(2_usize)] as i32) == (('r' as u8) as i32)));
+    assert!(((string[(0_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((string[(1_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((string[(2_usize)] as i32) == (('r' as libc::c_char) as i32)));
     assert!(((string[(3_usize)] as i32) == (0)));
-    let mut result: Vec<u8> = {
+    let mut result: Vec<libc::c_char> = {
         let mut __tmp2 = string.clone();
         __tmp2.pop();
-        let __from = b" foo\0".as_ptr();
+        let __from = c" foo".as_ptr();
         __tmp2.extend_from_slice(::std::slice::from_raw_parts(
             __from,
             (0..).position(|i| *__from.add(i) == 0).unwrap(),
@@ -207,15 +207,15 @@ unsafe fn main_0() -> i32 {
         __tmp2
     };
     assert!(((result.len() - 1) == (8_usize)));
-    assert!(((result[(0_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((result[(1_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((result[(2_usize)] as i32) == (('r' as u8) as i32)));
+    assert!(((result[(0_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((result[(1_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((result[(2_usize)] as i32) == (('r' as libc::c_char) as i32)));
     assert!(((result[(3_usize)] as i32) == (0)));
-    assert!(((result[(4_usize)] as i32) == ((' ' as u8) as i32)));
-    assert!(((result[(5_usize)] as i32) == (('f' as u8) as i32)));
-    assert!(((result[(6_usize)] as i32) == (('o' as u8) as i32)));
-    assert!(((result[(7_usize)] as i32) == (('o' as u8) as i32)));
-    let mut substr_0: Vec<u8> = {
+    assert!(((result[(4_usize)] as i32) == ((' ' as libc::c_char) as i32)));
+    assert!(((result[(5_usize)] as i32) == (('f' as libc::c_char) as i32)));
+    assert!(((result[(6_usize)] as i32) == (('o' as libc::c_char) as i32)));
+    assert!(((result[(7_usize)] as i32) == (('o' as libc::c_char) as i32)));
+    let mut substr_0: Vec<libc::c_char> = {
         let mut __tmp1 = result
             [(5_usize) as usize..::std::cmp::min((5_usize + 3_usize) as usize, result.len() - 1)]
             .to_vec();
@@ -223,10 +223,10 @@ unsafe fn main_0() -> i32 {
         __tmp1
     };
     assert!(((substr_0.len() - 1) == (3_usize)));
-    assert!(((substr_0[(0_usize)] as i32) == (('f' as u8) as i32)));
-    assert!(((substr_0[(1_usize)] as i32) == (('o' as u8) as i32)));
-    assert!(((substr_0[(2_usize)] as i32) == (('o' as u8) as i32)));
-    let mut substr_1: Vec<u8> = {
+    assert!(((substr_0[(0_usize)] as i32) == (('f' as libc::c_char) as i32)));
+    assert!(((substr_0[(1_usize)] as i32) == (('o' as libc::c_char) as i32)));
+    assert!(((substr_0[(2_usize)] as i32) == (('o' as libc::c_char) as i32)));
+    let mut substr_1: Vec<libc::c_char> = {
         let mut __tmp1 = result
             [(0_usize) as usize..::std::cmp::min((0_usize + 5_usize) as usize, result.len() - 1)]
             .to_vec();
@@ -234,12 +234,12 @@ unsafe fn main_0() -> i32 {
         __tmp1
     };
     assert!(((substr_1.len() - 1) == (5_usize)));
-    assert!(((substr_1[(0_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((substr_1[(1_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((substr_1[(2_usize)] as i32) == (('r' as u8) as i32)));
+    assert!(((substr_1[(0_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((substr_1[(1_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((substr_1[(2_usize)] as i32) == (('r' as libc::c_char) as i32)));
     assert!(((substr_1[(3_usize)] as i32) == (0)));
-    assert!(((substr_1[(4_usize)] as i32) == ((' ' as u8) as i32)));
-    let mut substr_2: Vec<u8> = {
+    assert!(((substr_1[(4_usize)] as i32) == ((' ' as libc::c_char) as i32)));
+    let mut substr_2: Vec<libc::c_char> = {
         let mut __tmp1 = result
             [(0_usize) as usize..::std::cmp::min((0_usize + 15_usize) as usize, result.len() - 1)]
             .to_vec();
@@ -247,16 +247,16 @@ unsafe fn main_0() -> i32 {
         __tmp1
     };
     assert!(((substr_2.len() - 1) == (8_usize)));
-    assert!(((substr_2[(0_usize)] as i32) == (('b' as u8) as i32)));
-    assert!(((substr_2[(1_usize)] as i32) == (('a' as u8) as i32)));
-    assert!(((substr_2[(2_usize)] as i32) == (('r' as u8) as i32)));
+    assert!(((substr_2[(0_usize)] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((substr_2[(1_usize)] as i32) == (('a' as libc::c_char) as i32)));
+    assert!(((substr_2[(2_usize)] as i32) == (('r' as libc::c_char) as i32)));
     assert!(((substr_2[(3_usize)] as i32) == (0)));
-    assert!(((substr_2[(4_usize)] as i32) == ((' ' as u8) as i32)));
-    assert!(((substr_2[(5_usize)] as i32) == (('f' as u8) as i32)));
-    assert!(((substr_2[(6_usize)] as i32) == (('o' as u8) as i32)));
-    assert!(((substr_2[(7_usize)] as i32) == (('o' as u8) as i32)));
+    assert!(((substr_2[(4_usize)] as i32) == ((' ' as libc::c_char) as i32)));
+    assert!(((substr_2[(5_usize)] as i32) == (('f' as libc::c_char) as i32)));
+    assert!(((substr_2[(6_usize)] as i32) == (('o' as libc::c_char) as i32)));
+    assert!(((substr_2[(7_usize)] as i32) == (('o' as libc::c_char) as i32)));
     let mut pos: usize = match result.iter().rposition(|&c| {
-        ::std::ffi::CStr::from_ptr(b"b\0".as_ptr() as *const i8)
+        ::std::ffi::CStr::from_ptr(c"b".as_ptr())
             .to_str()
             .unwrap()
             .contains(c as u8 as char)
@@ -266,7 +266,7 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((pos) == (0_usize)));
     pos = match result.iter().rposition(|&c| {
-        ::std::ffi::CStr::from_ptr(b"f\0".as_ptr() as *const i8)
+        ::std::ffi::CStr::from_ptr(c"f".as_ptr())
             .to_str()
             .unwrap()
             .contains(c as u8 as char)
@@ -276,7 +276,7 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((pos) == (5_usize)));
     pos = match result.iter().rposition(|&c| {
-        ::std::ffi::CStr::from_ptr(b"o\0".as_ptr() as *const i8)
+        ::std::ffi::CStr::from_ptr(c"o".as_ptr())
             .to_str()
             .unwrap()
             .contains(c as u8 as char)
@@ -286,7 +286,7 @@ unsafe fn main_0() -> i32 {
     };
     assert!(((pos) == (7_usize)));
     pos = match result.iter().rposition(|&c| {
-        ::std::ffi::CStr::from_ptr(b"x\0".as_ptr() as *const i8)
+        ::std::ffi::CStr::from_ptr(c"x".as_ptr())
             .to_str()
             .unwrap()
             .contains(c as u8 as char)
@@ -295,16 +295,16 @@ unsafe fn main_0() -> i32 {
         None => usize::MAX,
     };
     assert!(((pos) == ((-1_i64 as u64) as usize)));
-    let mut string_to_cast: Vec<u8> = {
-        let s = b"cast\0".as_ptr();
+    let mut string_to_cast: Vec<libc::c_char> = {
+        let s = c"cast".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
     let mut output_data: *mut u8 =
-        ((&mut string_to_cast[(0_usize)] as *mut u8) as *mut u8 as *mut u8);
-    assert!((((*output_data) as i32) == (('c' as u8) as i32)));
-    assert!((((*output_data.offset((1) as isize)) as i32) == (('a' as u8) as i32)));
-    assert!((((*output_data.offset((2) as isize)) as i32) == (('s' as u8) as i32)));
-    assert!((((*output_data.offset((3) as isize)) as i32) == (('t' as u8) as i32)));
+        ((&mut string_to_cast[(0_usize)] as *mut libc::c_char) as *mut libc::c_char as *mut u8);
+    assert!((((*output_data) as i32) == (('c' as libc::c_char) as i32)));
+    assert!((((*output_data.offset((1) as isize)) as i32) == (('a' as libc::c_char) as i32)));
+    assert!((((*output_data.offset((2) as isize)) as i32) == (('s' as libc::c_char) as i32)));
+    assert!((((*output_data.offset((3) as isize)) as i32) == (('t' as libc::c_char) as i32)));
     let mut t0: usize = (s1.len() - 1);
     let mut t1: usize = (t0).wrapping_add(((*p1) as usize));
     let mut t2: usize = (t1).wrapping_add((s2.len() - 1));
diff --git a/tests/unit/out/unsafe/string2.rs b/tests/unit/out/unsafe/string2.rs
index c874b8f4..720dcc78 100644
--- a/tests/unit/out/unsafe/string2.rs
+++ b/tests/unit/out/unsafe/string2.rs
@@ -12,16 +12,16 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr: Vec<u8> = {
-        let s = b"foo\0".as_ptr();
+    let mut arr: Vec<libc::c_char> = {
+        let s = c"foo".as_ptr();
         std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1).to_vec()
     };
-    arr[(1_usize)] = ('b' as u8);
-    let mut p: *const u8 = arr.as_ptr().offset((1) as isize);
-    assert!((((*p) as i32) == (('b' as u8) as i32)));
+    arr[(1_usize)] = ('b' as libc::c_char);
+    let mut p: *const libc::c_char = arr.as_ptr().offset((1) as isize);
+    assert!((((*p) as i32) == (('b' as libc::c_char) as i32)));
     assert!(
         arr == {
-            let s = b"fbo\0".as_ptr();
+            let s = c"fbo".as_ptr();
             std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
                 .to_vec()
         }
diff --git a/tests/unit/out/unsafe/string_escape.rs b/tests/unit/out/unsafe/string_escape.rs
index b07a1cb1..af93a63e 100644
--- a/tests/unit/out/unsafe/string_escape.rs
+++ b/tests/unit/out/unsafe/string_escape.rs
@@ -12,57 +12,57 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut special: *const u8 =
-        b"\x07\x08\t\n\x0b\x0c\r !\"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\xff\0".as_ptr();
-    static mut expected_0: [u8; 41] = unsafe {
+    let mut special: *const libc::c_char =
+        c"\x07\x08\t\n\x0b\x0c\r !\"#$%&\'()*+,-./:;<=>?@[\\]^_`{|}~\xff".as_ptr();
+    static mut expected_0: [libc::c_char; 41] = unsafe {
         [
-            7_u8,
-            8_u8,
-            9_u8,
-            10_u8,
-            11_u8,
-            12_u8,
-            13_u8,
-            32_u8,
-            33_u8,
-            34_u8,
-            35_u8,
-            36_u8,
-            37_u8,
-            38_u8,
-            39_u8,
-            40_u8,
-            41_u8,
-            42_u8,
-            43_u8,
-            44_u8,
-            45_u8,
-            46_u8,
-            47_u8,
-            58_u8,
-            59_u8,
-            60_u8,
-            61_u8,
-            62_u8,
-            63_u8,
-            64_u8,
-            91_u8,
-            92_u8,
-            93_u8,
-            94_u8,
-            95_u8,
-            96_u8,
-            123_u8,
-            124_u8,
-            125_u8,
-            126_u8,
-            (b'\xff' as u8),
+            (7 as libc::c_char),
+            (8 as libc::c_char),
+            (9 as libc::c_char),
+            (10 as libc::c_char),
+            (11 as libc::c_char),
+            (12 as libc::c_char),
+            (13 as libc::c_char),
+            (32 as libc::c_char),
+            (33 as libc::c_char),
+            (34 as libc::c_char),
+            (35 as libc::c_char),
+            (36 as libc::c_char),
+            (37 as libc::c_char),
+            (38 as libc::c_char),
+            (39 as libc::c_char),
+            (40 as libc::c_char),
+            (41 as libc::c_char),
+            (42 as libc::c_char),
+            (43 as libc::c_char),
+            (44 as libc::c_char),
+            (45 as libc::c_char),
+            (46 as libc::c_char),
+            (47 as libc::c_char),
+            (58 as libc::c_char),
+            (59 as libc::c_char),
+            (60 as libc::c_char),
+            (61 as libc::c_char),
+            (62 as libc::c_char),
+            (63 as libc::c_char),
+            (64 as libc::c_char),
+            (91 as libc::c_char),
+            (92 as libc::c_char),
+            (93 as libc::c_char),
+            (94 as libc::c_char),
+            (95 as libc::c_char),
+            (96 as libc::c_char),
+            (123 as libc::c_char),
+            (124 as libc::c_char),
+            (125 as libc::c_char),
+            (126 as libc::c_char),
+            (b'\xff' as libc::c_char),
         ]
     };;
     let mut i: i32 = 0;
     'loop_: while ((i)
-        < (((::std::mem::size_of::<[u8; 41]>() as usize)
-            .wrapping_div((::std::mem::size_of::<u8>() as usize))) as i32))
+        < (((::std::mem::size_of::<[libc::c_char; 41]>() as usize)
+            .wrapping_div((::std::mem::size_of::<libc::c_char>() as usize))) as i32))
     {
         assert!((((*special.offset((i) as isize)) as i32) == (expected_0[(i) as usize] as i32)));
         i.postfix_inc();
diff --git a/tests/unit/out/unsafe/string_h.rs b/tests/unit/out/unsafe/string_h.rs
index b606828b..bd89b1f5 100644
--- a/tests/unit/out/unsafe/string_h.rs
+++ b/tests/unit/out/unsafe/string_h.rs
@@ -7,19 +7,28 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn test_memcpy_0() {
-    let src: [u8; 6] = *b"hello\0";
-    let mut dst: [u8; 6] = [0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8];
+    let src: [libc::c_char; 6] = std::mem::transmute(*b"hello\0");
+    let mut dst: [libc::c_char; 6] = [
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+    ];
     let mut r: *mut ::libc::c_void = {
         if 6_usize != 0 {
             ::std::ptr::copy_nonoverlapping(
-                (src.as_ptr() as *const u8 as *const ::libc::c_void),
-                (dst.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+                (src.as_ptr() as *const libc::c_char as *const ::libc::c_void),
+                (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
                 6_usize as usize,
             )
         }
-        (dst.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+        (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
     };
-    assert!(((((r) == (dst.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)) as i32) != 0));
+    assert!(
+        ((((r) == (dst.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)) as i32) != 0)
+    );
     assert!(
         ((((((((((dst[(0) as usize] as i32) == ('h' as i32)) as i32) != 0)
             && ((((dst[(1) as usize] as i32) == ('e' as i32)) as i32) != 0)) as i32)
@@ -36,15 +45,17 @@ pub unsafe fn test_memcpy_0() {
     );
 }
 pub unsafe fn test_memset_1() {
-    let mut buf: [u8; 4] = [0_u8; 4];
+    let mut buf: [libc::c_char; 4] = [(0 as libc::c_char); 4];
     let mut r: *mut ::libc::c_void = {
-        let byte_0 = (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void) as *mut u8;
+        let byte_0 = (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void) as *mut u8;
         for offset in 0..4_usize {
             *byte_0.offset(offset as isize) = ('x' as i32) as u8;
         }
-        (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)
+        (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)
     };
-    assert!(((((r) == (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void)) as i32) != 0));
+    assert!(
+        ((((r) == (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void)) as i32) != 0)
+    );
     assert!(
         (((((((((((((buf[(0) as usize] as i32) == ('x' as i32)) as i32) != 0)
             && ((((buf[(1) as usize] as i32) == ('x' as i32)) as i32) != 0))
@@ -57,17 +68,32 @@ pub unsafe fn test_memset_1() {
     );
 }
 pub unsafe fn test_memcmp_2() {
-    let a: [u8; 4] = [1_u8, 2_u8, 3_u8, 4_u8];
-    let b: [u8; 4] = [1_u8, 2_u8, 3_u8, 4_u8];
-    let c: [u8; 4] = [1_u8, 2_u8, 9_u8, 4_u8];
+    let a: [libc::c_char; 4] = [
+        (1 as libc::c_char),
+        (2 as libc::c_char),
+        (3 as libc::c_char),
+        (4 as libc::c_char),
+    ];
+    let b: [libc::c_char; 4] = [
+        (1 as libc::c_char),
+        (2 as libc::c_char),
+        (3 as libc::c_char),
+        (4 as libc::c_char),
+    ];
+    let c: [libc::c_char; 4] = [
+        (1 as libc::c_char),
+        (2 as libc::c_char),
+        (9 as libc::c_char),
+        (4 as libc::c_char),
+    ];
     assert!(
         (((({
             let sa = core::slice::from_raw_parts(
-                (a.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (b.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (b.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let mut diff = 0_i32;
@@ -84,11 +110,11 @@ pub unsafe fn test_memcmp_2() {
     assert!(
         (((({
             let sa = core::slice::from_raw_parts(
-                (a.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (c.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let mut diff = 0_i32;
@@ -105,11 +131,11 @@ pub unsafe fn test_memcmp_2() {
     assert!(
         (((({
             let sa = core::slice::from_raw_parts(
-                (c.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (c.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (a.as_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (a.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 4_usize as usize,
             );
             let mut diff = 0_i32;
@@ -125,26 +151,27 @@ pub unsafe fn test_memcmp_2() {
     );
 }
 pub unsafe fn test_memmove_3() {
-    let mut buf: [u8; 6] = [
-        (('a' as i32) as u8),
-        (('b' as i32) as u8),
-        (('c' as i32) as u8),
-        (('d' as i32) as u8),
-        (('e' as i32) as u8),
-        (('\0' as i32) as u8),
+    let mut buf: [libc::c_char; 6] = [
+        (('a' as i32) as libc::c_char),
+        (('b' as i32) as libc::c_char),
+        (('c' as i32) as libc::c_char),
+        (('d' as i32) as libc::c_char),
+        (('e' as i32) as libc::c_char),
+        (('\0' as i32) as libc::c_char),
     ];
     let mut r: *mut ::libc::c_void = {
         if 4_usize != 0 {
             ::std::ptr::copy_nonoverlapping(
-                (buf.as_mut_ptr() as *const u8 as *const ::libc::c_void),
-                (buf.as_mut_ptr().offset((1) as isize) as *mut u8 as *mut ::libc::c_void),
+                (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void),
+                (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void),
                 4_usize as usize,
             )
         }
-        (buf.as_mut_ptr().offset((1) as isize) as *mut u8 as *mut ::libc::c_void)
+        (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void)
     };
     assert!(
-        ((((r) == (buf.as_mut_ptr().offset((1) as isize) as *mut u8 as *mut ::libc::c_void))
+        ((((r)
+            == (buf.as_mut_ptr().offset((1) as isize) as *mut libc::c_char as *mut ::libc::c_void))
             as i32)
             != 0)
     );
@@ -164,148 +191,135 @@ pub unsafe fn test_memmove_3() {
     );
 }
 pub unsafe fn test_strchr_4() {
-    let mut s: *const u8 = (b"hello world\0".as_ptr().cast_mut()).cast_const();
-    let mut r: *mut u8 =
-        libc::strchr((s as *mut u8).cast_const() as *const i8, ('w' as i32)) as *mut u8;
+    let mut s: *const libc::c_char = (c"hello world".as_ptr().cast_mut()).cast_const();
+    let mut r: *mut libc::c_char =
+        libc::strchr((s as *mut libc::c_char).cast_const(), ('w' as i32));
     assert!((((!((r).is_null())) as i32) != 0));
     assert!((((((*r) as i32) == ('w' as i32)) as i32) != 0));
     assert!(
-        ((((libc::strchr((s as *mut u8).cast_const() as *const i8, ('z' as i32)) as *mut u8)
-            .is_null()) as i32)
+        ((((libc::strchr((s as *mut libc::c_char).cast_const(), ('z' as i32))).is_null()) as i32)
             != 0)
     );
 }
 pub unsafe fn test_strlen_5() {
+    assert!(((((libc::strlen((c"".as_ptr().cast_mut()).cast_const())) == (0_usize)) as i32) != 0));
     assert!(
-        ((((libc::strlen((b"\0".as_ptr().cast_mut()).cast_const() as *const i8)) == (0_usize))
-            as i32)
-            != 0)
+        ((((libc::strlen((c"hello".as_ptr().cast_mut()).cast_const())) == (5_usize)) as i32) != 0)
     );
     assert!(
-        ((((libc::strlen((b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8)) == (5_usize))
+        ((((libc::strlen((c"hello world".as_ptr().cast_mut()).cast_const())) == (11_usize))
             as i32)
             != 0)
     );
-    assert!(
-        ((((libc::strlen((b"hello world\0".as_ptr().cast_mut()).cast_const() as *const i8))
-            == (11_usize)) as i32)
-            != 0)
-    );
 }
 pub unsafe fn test_strcmp_6() {
     assert!(
         ((((libc::strcmp(
-            (b"abc\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"abc\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"abc".as_ptr().cast_mut()).cast_const(),
+            (c"abc".as_ptr().cast_mut()).cast_const()
         )) == (0)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strcmp(
-            (b"abc\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"abd\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"abc".as_ptr().cast_mut()).cast_const(),
+            (c"abd".as_ptr().cast_mut()).cast_const()
         )) < (0)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strcmp(
-            (b"abd\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"abc\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"abd".as_ptr().cast_mut()).cast_const(),
+            (c"abc".as_ptr().cast_mut()).cast_const()
         )) > (0)) as i32)
             != 0)
     );
-    let mut p: *const u8 = (b"abc\0".as_ptr().cast_mut()).cast_const();
-    let mut q: *const u8 = (b"abd\0".as_ptr().cast_mut()).cast_const();
-    let mut buf: [u8; 4] = [
-        (('a' as i32) as u8),
-        (('b' as i32) as u8),
-        (('c' as i32) as u8),
-        (('\0' as i32) as u8),
+    let mut p: *const libc::c_char = (c"abc".as_ptr().cast_mut()).cast_const();
+    let mut q: *const libc::c_char = (c"abd".as_ptr().cast_mut()).cast_const();
+    let mut buf: [libc::c_char; 4] = [
+        (('a' as i32) as libc::c_char),
+        (('b' as i32) as libc::c_char),
+        (('c' as i32) as libc::c_char),
+        (('\0' as i32) as libc::c_char),
     ];
-    assert!(((((libc::strcmp(p as *const i8, p as *const i8)) == (0)) as i32) != 0));
-    assert!(((((libc::strcmp(p as *const i8, q as *const i8)) < (0)) as i32) != 0));
-    assert!(
-        ((((libc::strcmp((buf.as_mut_ptr()).cast_const() as *const i8, p as *const i8)) == (0))
-            as i32)
-            != 0)
-    );
+    assert!(((((libc::strcmp(p, p)) == (0)) as i32) != 0));
+    assert!(((((libc::strcmp(p, q)) < (0)) as i32) != 0));
+    assert!(((((libc::strcmp((buf.as_mut_ptr()).cast_const(), p)) == (0)) as i32) != 0));
 }
 pub unsafe fn test_strncmp_7() {
     assert!(
         ((((libc::strncmp(
-            (b"abcdef\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"abcxyz\0".as_ptr().cast_mut()).cast_const() as *const i8,
+            (c"abcdef".as_ptr().cast_mut()).cast_const(),
+            (c"abcxyz".as_ptr().cast_mut()).cast_const(),
             3_usize as usize
         )) == (0)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strncmp(
-            (b"abcdef\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"abcxyz\0".as_ptr().cast_mut()).cast_const() as *const i8,
+            (c"abcdef".as_ptr().cast_mut()).cast_const(),
+            (c"abcxyz".as_ptr().cast_mut()).cast_const(),
             4_usize as usize
         )) < (0)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strncmp(
-            (b"abcxyz\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"abcdef\0".as_ptr().cast_mut()).cast_const() as *const i8,
+            (c"abcxyz".as_ptr().cast_mut()).cast_const(),
+            (c"abcdef".as_ptr().cast_mut()).cast_const(),
             4_usize as usize
         )) > (0)) as i32)
             != 0)
     );
-    let mut p: *const u8 = (b"abcdef\0".as_ptr().cast_mut()).cast_const();
-    let mut q: *const u8 = (b"abcxyz\0".as_ptr().cast_mut()).cast_const();
-    let mut buf: [u8; 7] = [
-        (('a' as i32) as u8),
-        (('b' as i32) as u8),
-        (('c' as i32) as u8),
-        (('d' as i32) as u8),
-        (('e' as i32) as u8),
-        (('f' as i32) as u8),
-        (('\0' as i32) as u8),
+    let mut p: *const libc::c_char = (c"abcdef".as_ptr().cast_mut()).cast_const();
+    let mut q: *const libc::c_char = (c"abcxyz".as_ptr().cast_mut()).cast_const();
+    let mut buf: [libc::c_char; 7] = [
+        (('a' as i32) as libc::c_char),
+        (('b' as i32) as libc::c_char),
+        (('c' as i32) as libc::c_char),
+        (('d' as i32) as libc::c_char),
+        (('e' as i32) as libc::c_char),
+        (('f' as i32) as libc::c_char),
+        (('\0' as i32) as libc::c_char),
     ];
     let mut n: usize = 3_usize;
-    assert!(((((libc::strncmp(p as *const i8, q as *const i8, n as usize)) == (0)) as i32) != 0));
-    assert!(
-        ((((libc::strncmp(
-            p as *const i8,
-            q as *const i8,
-            (n).wrapping_add(1_usize) as usize
-        )) < (0)) as i32)
-            != 0)
-    );
+    assert!(((((libc::strncmp(p, q, n as usize)) == (0)) as i32) != 0));
+    assert!(((((libc::strncmp(p, q, (n).wrapping_add(1_usize) as usize)) < (0)) as i32) != 0));
     assert!(
-        ((((libc::strncmp(
-            (buf.as_mut_ptr()).cast_const() as *const i8,
-            p as *const i8,
-            6_usize as usize
-        )) == (0)) as i32)
+        ((((libc::strncmp((buf.as_mut_ptr()).cast_const(), p, 6_usize as usize)) == (0)) as i32)
             != 0)
     );
 }
 pub unsafe fn test_memchr_8() {
-    let data: [u8; 4] = [16_u8, 32_u8, 48_u8, 64_u8];
+    let data: [libc::c_char; 4] = [
+        (16 as libc::c_char),
+        (32 as libc::c_char),
+        (48 as libc::c_char),
+        (64 as libc::c_char),
+    ];
     let mut r: *mut ::libc::c_void = libc::memchr(
-        (data.as_ptr() as *const u8 as *const ::libc::c_void) as *const ::libc::c_void,
+        (data.as_ptr() as *const libc::c_char as *const ::libc::c_void) as *const ::libc::c_void,
         48,
         4_usize as usize,
     );
     assert!(
-        ((((r) == ((&data[(2) as usize] as *const u8) as *mut u8 as *mut ::libc::c_void)) as i32)
+        ((((r)
+            == ((&data[(2) as usize] as *const libc::c_char) as *mut libc::c_char
+                as *mut ::libc::c_void)) as i32)
             != 0)
     );
     assert!(
         ((((libc::memchr(
-            (data.as_ptr() as *const u8 as *const ::libc::c_void) as *const ::libc::c_void,
+            (data.as_ptr() as *const libc::c_char as *const ::libc::c_void)
+                as *const ::libc::c_void,
             153,
             4_usize as usize
         ))
         .is_null()) as i32)
             != 0)
     );
-    let mut p: *const ::libc::c_void = (data.as_ptr() as *const u8 as *const ::libc::c_void);
+    let mut p: *const ::libc::c_void =
+        (data.as_ptr() as *const libc::c_char as *const ::libc::c_void);
     let mut n: usize = 4_usize;
     assert!(
         ((((libc::memchr(p as *const ::libc::c_void, 16, n as usize))
@@ -314,205 +328,197 @@ pub unsafe fn test_memchr_8() {
     );
 }
 pub unsafe fn test_strrchr_9() {
-    let mut s: *const u8 = (b"hello world\0".as_ptr().cast_mut()).cast_const();
-    let mut r: *mut u8 =
-        libc::strrchr((s as *mut u8).cast_const() as *const i8, ('l' as i32)) as *mut u8;
+    let mut s: *const libc::c_char = (c"hello world".as_ptr().cast_mut()).cast_const();
+    let mut r: *mut libc::c_char =
+        libc::strrchr((s as *mut libc::c_char).cast_const(), ('l' as i32));
     assert!((((!((r).is_null())) as i32) != 0));
     assert!((((((*r) as i32) == ('l' as i32)) as i32) != 0));
-    assert!(((((r) == (s.offset((9) as isize) as *mut u8)) as i32) != 0));
+    assert!(((((r) == (s.offset((9) as isize) as *mut libc::c_char)) as i32) != 0));
     assert!(
-        ((((libc::strrchr((s as *mut u8).cast_const() as *const i8, ('z' as i32)) as *mut u8)
-            .is_null()) as i32)
+        ((((libc::strrchr((s as *mut libc::c_char).cast_const(), ('z' as i32))).is_null()) as i32)
             != 0)
     );
-    let mut buf: [u8; 4] = [
-        (('a' as i32) as u8),
-        (('b' as i32) as u8),
-        (('a' as i32) as u8),
-        (('\0' as i32) as u8),
+    let mut buf: [libc::c_char; 4] = [
+        (('a' as i32) as libc::c_char),
+        (('b' as i32) as libc::c_char),
+        (('a' as i32) as libc::c_char),
+        (('\0' as i32) as libc::c_char),
     ];
     assert!(
-        ((((libc::strrchr((buf.as_mut_ptr()).cast_const() as *const i8, ('a' as i32)) as *mut u8)
-            == (&mut buf[(2) as usize] as *mut u8)) as i32)
+        ((((libc::strrchr((buf.as_mut_ptr()).cast_const(), ('a' as i32)))
+            == (&mut buf[(2) as usize] as *mut libc::c_char)) as i32)
             != 0)
     );
 }
 pub unsafe fn test_strdup_10() {
-    let mut d: *mut u8 = libcc2rs::strdup_unsafe((b"hello\0".as_ptr().cast_mut()).cast_const());
+    let mut d: *mut libc::c_char =
+        libcc2rs::strdup_unsafe((c"hello".as_ptr().cast_mut()).cast_const());
     assert!((((!((d).is_null())) as i32) != 0));
     assert!(
         ((((libc::strcmp(
-            (d).cast_const() as *const i8,
-            (b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (d).cast_const(),
+            (c"hello".as_ptr().cast_mut()).cast_const()
         )) == (0)) as i32)
             != 0)
     );
-    libcc2rs::free_unsafe((d as *mut u8 as *mut ::libc::c_void));
-    let mut p: *const u8 = (b"world\0".as_ptr().cast_mut()).cast_const();
-    let mut buf: [u8; 4] = [
-        (('a' as i32) as u8),
-        (('b' as i32) as u8),
-        (('c' as i32) as u8),
-        (('\0' as i32) as u8),
+    libcc2rs::free_unsafe((d as *mut libc::c_char as *mut ::libc::c_void));
+    let mut p: *const libc::c_char = (c"world".as_ptr().cast_mut()).cast_const();
+    let mut buf: [libc::c_char; 4] = [
+        (('a' as i32) as libc::c_char),
+        (('b' as i32) as libc::c_char),
+        (('c' as i32) as libc::c_char),
+        (('\0' as i32) as libc::c_char),
     ];
-    let mut d2: *mut u8 = libcc2rs::strdup_unsafe(p);
+    let mut d2: *mut libc::c_char = libcc2rs::strdup_unsafe(p);
     assert!((((!((d2).is_null())) as i32) != 0));
-    assert!(
-        ((((libc::strcmp((d2).cast_const() as *const i8, p as *const i8)) == (0)) as i32) != 0)
-    );
-    libcc2rs::free_unsafe((d2 as *mut u8 as *mut ::libc::c_void));
-    let mut d3: *mut u8 = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const());
+    assert!(((((libc::strcmp((d2).cast_const(), p)) == (0)) as i32) != 0));
+    libcc2rs::free_unsafe((d2 as *mut libc::c_char as *mut ::libc::c_void));
+    let mut d3: *mut libc::c_char = libcc2rs::strdup_unsafe((buf.as_mut_ptr()).cast_const());
     assert!((((!((d3).is_null())) as i32) != 0));
     assert!(
-        ((((libc::strcmp(
-            (d3).cast_const() as *const i8,
-            (buf.as_mut_ptr()).cast_const() as *const i8
-        )) == (0)) as i32)
-            != 0)
+        ((((libc::strcmp((d3).cast_const(), (buf.as_mut_ptr()).cast_const())) == (0)) as i32) != 0)
     );
-    libcc2rs::free_unsafe((d3 as *mut u8 as *mut ::libc::c_void));
+    libcc2rs::free_unsafe((d3 as *mut libc::c_char as *mut ::libc::c_void));
 }
 pub unsafe fn test_strcspn_11() {
     assert!(
         ((((libc::strcspn(
-            (b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"el\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"hello".as_ptr().cast_mut()).cast_const(),
+            (c"el".as_ptr().cast_mut()).cast_const()
         )) == (1_usize)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strcspn(
-            (b"abc\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"xyz\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"abc".as_ptr().cast_mut()).cast_const(),
+            (c"xyz".as_ptr().cast_mut()).cast_const()
         )) == (3_usize)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strcspn(
-            (b"\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"abc\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"".as_ptr().cast_mut()).cast_const(),
+            (c"abc".as_ptr().cast_mut()).cast_const()
         )) == (0_usize)) as i32)
             != 0)
     );
-    let mut s: *const u8 = (b"hello\0".as_ptr().cast_mut()).cast_const();
-    let mut rej: *const u8 = (b"el\0".as_ptr().cast_mut()).cast_const();
-    assert!(((((libc::strcspn(s as *const i8, rej as *const i8)) == (1_usize)) as i32) != 0));
+    let mut s: *const libc::c_char = (c"hello".as_ptr().cast_mut()).cast_const();
+    let mut rej: *const libc::c_char = (c"el".as_ptr().cast_mut()).cast_const();
+    assert!(((((libc::strcspn(s, rej)) == (1_usize)) as i32) != 0));
 }
 pub unsafe fn test_strspn_12() {
     assert!(
         ((((libc::strspn(
-            (b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"hel\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"hello".as_ptr().cast_mut()).cast_const(),
+            (c"hel".as_ptr().cast_mut()).cast_const()
         )) == (4_usize)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strspn(
-            (b"abc\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"xyz\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"abc".as_ptr().cast_mut()).cast_const(),
+            (c"xyz".as_ptr().cast_mut()).cast_const()
         )) == (0_usize)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strspn(
-            (b"aaa\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"a\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"aaa".as_ptr().cast_mut()).cast_const(),
+            (c"a".as_ptr().cast_mut()).cast_const()
         )) == (3_usize)) as i32)
             != 0)
     );
-    let mut s: *const u8 = (b"hello\0".as_ptr().cast_mut()).cast_const();
-    let mut acc: *const u8 = (b"hel\0".as_ptr().cast_mut()).cast_const();
-    assert!(((((libc::strspn(s as *const i8, acc as *const i8)) == (4_usize)) as i32) != 0));
+    let mut s: *const libc::c_char = (c"hello".as_ptr().cast_mut()).cast_const();
+    let mut acc: *const libc::c_char = (c"hel".as_ptr().cast_mut()).cast_const();
+    assert!(((((libc::strspn(s, acc)) == (4_usize)) as i32) != 0));
 }
 pub unsafe fn test_strstr_13() {
-    let mut h: *const u8 = (b"hello world\0".as_ptr().cast_mut()).cast_const();
-    let mut r: *mut u8 = libc::strstr(
-        (h as *mut u8).cast_const() as *const i8,
-        (b"world\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    ) as *mut u8;
+    let mut h: *const libc::c_char = (c"hello world".as_ptr().cast_mut()).cast_const();
+    let mut r: *mut libc::c_char = libc::strstr(
+        (h as *mut libc::c_char).cast_const(),
+        (c"world".as_ptr().cast_mut()).cast_const(),
+    );
     assert!((((!((r).is_null())) as i32) != 0));
-    assert!(((((r) == (h.offset((6) as isize) as *mut u8)) as i32) != 0));
+    assert!(((((r) == (h.offset((6) as isize) as *mut libc::c_char)) as i32) != 0));
     assert!(
         ((((libc::strstr(
-            (h as *mut u8).cast_const() as *const i8,
-            (b"xyz\0".as_ptr().cast_mut()).cast_const() as *const i8
-        ) as *mut u8)
-            .is_null()) as i32)
-            != 0)
-    );
-    let mut buf: [u8; 6] = [
-        (('h' as i32) as u8),
-        (('e' as i32) as u8),
-        (('l' as i32) as u8),
-        (('l' as i32) as u8),
-        (('o' as i32) as u8),
-        (('\0' as i32) as u8),
+            (h as *mut libc::c_char).cast_const(),
+            (c"xyz".as_ptr().cast_mut()).cast_const()
+        ))
+        .is_null()) as i32)
+            != 0)
+    );
+    let mut buf: [libc::c_char; 6] = [
+        (('h' as i32) as libc::c_char),
+        (('e' as i32) as libc::c_char),
+        (('l' as i32) as libc::c_char),
+        (('l' as i32) as libc::c_char),
+        (('o' as i32) as libc::c_char),
+        (('\0' as i32) as libc::c_char),
     ];
     assert!(
         ((((libc::strstr(
-            (buf.as_mut_ptr()).cast_const() as *const i8,
-            (b"ll\0".as_ptr().cast_mut()).cast_const() as *const i8
-        ) as *mut u8)
-            == (&mut buf[(2) as usize] as *mut u8)) as i32)
+            (buf.as_mut_ptr()).cast_const(),
+            (c"ll".as_ptr().cast_mut()).cast_const()
+        )) == (&mut buf[(2) as usize] as *mut libc::c_char)) as i32)
             != 0)
     );
 }
 pub unsafe fn test_strpbrk_14() {
-    let mut s: *const u8 = (b"hello world\0".as_ptr().cast_mut()).cast_const();
-    let mut r: *mut u8 = libc::strpbrk(
-        (s as *mut u8).cast_const() as *const i8,
-        (b"wo\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    ) as *mut u8;
+    let mut s: *const libc::c_char = (c"hello world".as_ptr().cast_mut()).cast_const();
+    let mut r: *mut libc::c_char = libc::strpbrk(
+        (s as *mut libc::c_char).cast_const(),
+        (c"wo".as_ptr().cast_mut()).cast_const(),
+    );
     assert!((((!((r).is_null())) as i32) != 0));
-    assert!(((((r) == (s.offset((4) as isize) as *mut u8)) as i32) != 0));
+    assert!(((((r) == (s.offset((4) as isize) as *mut libc::c_char)) as i32) != 0));
     assert!(
         ((((libc::strpbrk(
-            (s as *mut u8).cast_const() as *const i8,
-            (b"xyz\0".as_ptr().cast_mut()).cast_const() as *const i8
-        ) as *mut u8)
-            .is_null()) as i32)
+            (s as *mut libc::c_char).cast_const(),
+            (c"xyz".as_ptr().cast_mut()).cast_const()
+        ))
+        .is_null()) as i32)
             != 0)
     );
-    let mut buf: [u8; 4] = [
-        (('a' as i32) as u8),
-        (('b' as i32) as u8),
-        (('c' as i32) as u8),
-        (('\0' as i32) as u8),
+    let mut buf: [libc::c_char; 4] = [
+        (('a' as i32) as libc::c_char),
+        (('b' as i32) as libc::c_char),
+        (('c' as i32) as libc::c_char),
+        (('\0' as i32) as libc::c_char),
     ];
     assert!(
         ((((libc::strpbrk(
-            (buf.as_mut_ptr()).cast_const() as *const i8,
-            (b"b\0".as_ptr().cast_mut()).cast_const() as *const i8
-        ) as *mut u8)
-            == (&mut buf[(1) as usize] as *mut u8)) as i32)
+            (buf.as_mut_ptr()).cast_const(),
+            (c"b".as_ptr().cast_mut()).cast_const()
+        )) == (&mut buf[(1) as usize] as *mut libc::c_char)) as i32)
             != 0)
     );
 }
 pub unsafe fn test_strcasecmp_15() {
     assert!(
         ((((libc::strcasecmp(
-            (b"HELLO\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"HELLO".as_ptr().cast_mut()).cast_const(),
+            (c"hello".as_ptr().cast_mut()).cast_const()
         )) == (0)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strcasecmp(
-            (b"abc\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"abd\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"abc".as_ptr().cast_mut()).cast_const(),
+            (c"abd".as_ptr().cast_mut()).cast_const()
         )) < (0)) as i32)
             != 0)
     );
     assert!(
         ((((libc::strcasecmp(
-            (b"abd\0".as_ptr().cast_mut()).cast_const() as *const i8,
-            (b"abc\0".as_ptr().cast_mut()).cast_const() as *const i8
+            (c"abd".as_ptr().cast_mut()).cast_const(),
+            (c"abc".as_ptr().cast_mut()).cast_const()
         )) > (0)) as i32)
             != 0)
     );
-    let mut p: *const u8 = (b"FOO\0".as_ptr().cast_mut()).cast_const();
-    let mut q: *const u8 = (b"foo\0".as_ptr().cast_mut()).cast_const();
-    assert!(((((libc::strcasecmp(p as *const i8, q as *const i8)) == (0)) as i32) != 0));
+    let mut p: *const libc::c_char = (c"FOO".as_ptr().cast_mut()).cast_const();
+    let mut q: *const libc::c_char = (c"foo".as_ptr().cast_mut()).cast_const();
+    assert!(((((libc::strcasecmp(p, q)) == (0)) as i32) != 0));
 }
 pub fn main() {
     unsafe {
diff --git a/tests/unit/out/unsafe/string_literals.rs b/tests/unit/out/unsafe/string_literals.rs
index f9c932d3..0001addf 100644
--- a/tests/unit/out/unsafe/string_literals.rs
+++ b/tests/unit/out/unsafe/string_literals.rs
@@ -6,29 +6,31 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn foo_mut_0(mut str: *mut u8) {}
-pub unsafe fn foo_const_1(mut str: *const u8) {}
+pub unsafe fn foo_mut_0(mut str: *mut libc::c_char) {}
+pub unsafe fn foo_const_1(mut str: *const libc::c_char) {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut immutable_strings: [*const u8; 3] = [b"a\0".as_ptr(), b"b\0".as_ptr(), b"c\0".as_ptr()];
-    let mut immutable_string: *const u8 = b"hello\0".as_ptr();
-    let mut mutable_string_arr: [u8; 9] = *b"papanasi\0";
-    let immutable_string_arr: [u8; 9] = *b"papanasi\0";
-    let mut immutable_empty: *const u8 = b"\0".as_ptr();
-    let mut mutable_empty_arr: [u8; 1] = [0u8; 1];
-    let immutable_empty_arr: [u8; 1] = [0u8; 1];
+    let mut immutable_strings: [*const libc::c_char; 3] =
+        [c"a".as_ptr(), c"b".as_ptr(), c"c".as_ptr()];
+    let mut immutable_string: *const libc::c_char = c"hello".as_ptr();
+    let mut mutable_string_arr: [libc::c_char; 9] = std::mem::transmute(*b"papanasi\0");
+    let immutable_string_arr: [libc::c_char; 9] = std::mem::transmute(*b"papanasi\0");
+    let mut immutable_empty: *const libc::c_char = c"".as_ptr();
+    let mut mutable_empty_arr: [libc::c_char; 1] = [0 as libc::c_char; 1];
+    let immutable_empty_arr: [libc::c_char; 1] = [0 as libc::c_char; 1];
     (unsafe { foo_mut_0(mutable_string_arr.as_mut_ptr()) });
-    (unsafe { foo_const_1(b"world\0".as_ptr()) });
+    (unsafe { foo_const_1(c"world".as_ptr()) });
     (unsafe { foo_const_1(immutable_string) });
     (unsafe { foo_const_1(immutable_string_arr.as_ptr()) });
-    (unsafe { foo_const_1(b"\0".as_ptr()) });
+    (unsafe { foo_const_1(c"".as_ptr()) });
     (unsafe { foo_const_1(immutable_empty) });
     (unsafe { foo_const_1(immutable_empty_arr.as_ptr()) });
-    let inited_through_init_list: [u8; 21] = *b"papanasi cu smantana\0";
+    let inited_through_init_list: [libc::c_char; 21] =
+        std::mem::transmute(*b"papanasi cu smantana\0");
     (unsafe { foo_const_1(inited_through_init_list.as_ptr()) });
     return 0;
 }
diff --git a/tests/unit/out/unsafe/string_literals_c.rs b/tests/unit/out/unsafe/string_literals_c.rs
index 9dff89dd..80da83d0 100644
--- a/tests/unit/out/unsafe/string_literals_c.rs
+++ b/tests/unit/out/unsafe/string_literals_c.rs
@@ -6,46 +6,47 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn foo_mut_0(mut str: *mut u8) {}
-pub unsafe fn foo_const_1(mut str: *const u8) {}
+pub unsafe fn foo_mut_0(mut str: *mut libc::c_char) {}
+pub unsafe fn foo_const_1(mut str: *const libc::c_char) {}
 pub fn main() {
     unsafe {
         std::process::exit(main_0() as i32);
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut mutable_strings: [*mut u8; 3] = [
-        b"a\0".as_ptr().cast_mut(),
-        b"b\0".as_ptr().cast_mut(),
-        b"c\0".as_ptr().cast_mut(),
+    let mut mutable_strings: [*mut libc::c_char; 3] = [
+        c"a".as_ptr().cast_mut(),
+        c"b".as_ptr().cast_mut(),
+        c"c".as_ptr().cast_mut(),
     ];
-    let mut immutable_strings: [*const u8; 3] = [
-        (b"a\0".as_ptr().cast_mut()).cast_const(),
-        (b"b\0".as_ptr().cast_mut()).cast_const(),
-        (b"c\0".as_ptr().cast_mut()).cast_const(),
+    let mut immutable_strings: [*const libc::c_char; 3] = [
+        (c"a".as_ptr().cast_mut()).cast_const(),
+        (c"b".as_ptr().cast_mut()).cast_const(),
+        (c"c".as_ptr().cast_mut()).cast_const(),
     ];
-    let mut mutable_string: *mut u8 = b"hello\0".as_ptr().cast_mut();
-    let mut immutable_string: *const u8 = (b"hello\0".as_ptr().cast_mut()).cast_const();
-    let mut mutable_string_arr: [u8; 9] = *b"papanasi\0";
-    let immutable_string_arr: [u8; 9] = *b"papanasi\0";
-    let mut mutable_empty: *mut u8 = b"\0".as_ptr().cast_mut();
-    let mut immutable_empty: *const u8 = (b"\0".as_ptr().cast_mut()).cast_const();
-    let mut mutable_empty_arr: [u8; 1] = [0u8; 1];
-    let immutable_empty_arr: [u8; 1] = [0u8; 1];
-    (unsafe { foo_mut_0(b"world\0".as_ptr().cast_mut()) });
+    let mut mutable_string: *mut libc::c_char = c"hello".as_ptr().cast_mut();
+    let mut immutable_string: *const libc::c_char = (c"hello".as_ptr().cast_mut()).cast_const();
+    let mut mutable_string_arr: [libc::c_char; 9] = std::mem::transmute(*b"papanasi\0");
+    let immutable_string_arr: [libc::c_char; 9] = std::mem::transmute(*b"papanasi\0");
+    let mut mutable_empty: *mut libc::c_char = c"".as_ptr().cast_mut();
+    let mut immutable_empty: *const libc::c_char = (c"".as_ptr().cast_mut()).cast_const();
+    let mut mutable_empty_arr: [libc::c_char; 1] = [0 as libc::c_char; 1];
+    let immutable_empty_arr: [libc::c_char; 1] = [0 as libc::c_char; 1];
+    (unsafe { foo_mut_0(c"world".as_ptr().cast_mut()) });
     (unsafe { foo_mut_0(mutable_string) });
     (unsafe { foo_mut_0(mutable_string_arr.as_mut_ptr()) });
-    (unsafe { foo_const_1((b"world\0".as_ptr().cast_mut()).cast_const()) });
+    (unsafe { foo_const_1((c"world".as_ptr().cast_mut()).cast_const()) });
     (unsafe { foo_const_1((mutable_string).cast_const()) });
     (unsafe { foo_const_1(immutable_string) });
     (unsafe { foo_const_1((mutable_string_arr.as_mut_ptr()).cast_const()) });
     (unsafe { foo_const_1(immutable_string_arr.as_ptr()) });
-    (unsafe { foo_const_1((b"\0".as_ptr().cast_mut()).cast_const()) });
+    (unsafe { foo_const_1((c"".as_ptr().cast_mut()).cast_const()) });
     (unsafe { foo_const_1((mutable_empty).cast_const()) });
     (unsafe { foo_const_1(immutable_empty) });
     (unsafe { foo_const_1((mutable_empty_arr.as_mut_ptr()).cast_const()) });
     (unsafe { foo_const_1(immutable_empty_arr.as_ptr()) });
-    let inited_through_init_list: [u8; 21] = *b"papanasi cu smantana\0";
+    let inited_through_init_list: [libc::c_char; 21] =
+        std::mem::transmute(*b"papanasi cu smantana\0");
     (unsafe { foo_const_1(inited_through_init_list.as_ptr()) });
     return 0;
 }
diff --git a/tests/unit/out/unsafe/string_literals_concat.rs b/tests/unit/out/unsafe/string_literals_concat.rs
index ce35fafb..befe367d 100644
--- a/tests/unit/out/unsafe/string_literals_concat.rs
+++ b/tests/unit/out/unsafe/string_literals_concat.rs
@@ -12,20 +12,20 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut joined: *const u8 = b"alpha\nbeta\ngamma\n\0".as_ptr();
-    assert!((((*joined.offset((0) as isize)) as i32) == (('a' as u8) as i32)));
-    assert!((((*joined.offset((5) as isize)) as i32) == (('\n' as u8) as i32)));
-    assert!((((*joined.offset((6) as isize)) as i32) == (('b' as u8) as i32)));
-    let mut arr: [u8; 7] = *b"foobar\0";
-    assert!(((arr[(0) as usize] as i32) == (('f' as u8) as i32)));
-    assert!(((arr[(3) as usize] as i32) == (('b' as u8) as i32)));
-    assert!(((arr[(5) as usize] as i32) == (('r' as u8) as i32)));
-    assert!(((arr[(6) as usize] as i32) == (('\0' as u8) as i32)));
-    let mut split_pieces: *const u8 = b"abcdefghi\0".as_ptr();
-    assert!((((*split_pieces.offset((0) as isize)) as i32) == (('a' as u8) as i32)));
-    assert!((((*split_pieces.offset((3) as isize)) as i32) == (('d' as u8) as i32)));
-    assert!((((*split_pieces.offset((6) as isize)) as i32) == (('g' as u8) as i32)));
-    assert!((((*split_pieces.offset((8) as isize)) as i32) == (('i' as u8) as i32)));
-    assert!((((*split_pieces.offset((9) as isize)) as i32) == (('\0' as u8) as i32)));
+    let mut joined: *const libc::c_char = c"alpha\nbeta\ngamma\n".as_ptr();
+    assert!((((*joined.offset((0) as isize)) as i32) == (('a' as libc::c_char) as i32)));
+    assert!((((*joined.offset((5) as isize)) as i32) == (('\n' as libc::c_char) as i32)));
+    assert!((((*joined.offset((6) as isize)) as i32) == (('b' as libc::c_char) as i32)));
+    let mut arr: [libc::c_char; 7] = std::mem::transmute(*b"foobar\0");
+    assert!(((arr[(0) as usize] as i32) == (('f' as libc::c_char) as i32)));
+    assert!(((arr[(3) as usize] as i32) == (('b' as libc::c_char) as i32)));
+    assert!(((arr[(5) as usize] as i32) == (('r' as libc::c_char) as i32)));
+    assert!(((arr[(6) as usize] as i32) == (('\0' as libc::c_char) as i32)));
+    let mut split_pieces: *const libc::c_char = c"abcdefghi".as_ptr();
+    assert!((((*split_pieces.offset((0) as isize)) as i32) == (('a' as libc::c_char) as i32)));
+    assert!((((*split_pieces.offset((3) as isize)) as i32) == (('d' as libc::c_char) as i32)));
+    assert!((((*split_pieces.offset((6) as isize)) as i32) == (('g' as libc::c_char) as i32)));
+    assert!((((*split_pieces.offset((8) as isize)) as i32) == (('i' as libc::c_char) as i32)));
+    assert!((((*split_pieces.offset((9) as isize)) as i32) == (('\0' as libc::c_char) as i32)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/string_literals_concat_c.rs b/tests/unit/out/unsafe/string_literals_concat_c.rs
index 2d77bff8..0dc9f60a 100644
--- a/tests/unit/out/unsafe/string_literals_concat_c.rs
+++ b/tests/unit/out/unsafe/string_literals_concat_c.rs
@@ -12,12 +12,12 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut arr: [u8; 7] = *b"foobar\0";
+    let mut arr: [libc::c_char; 7] = std::mem::transmute(*b"foobar\0");
     assert!(((((arr[(0) as usize] as i32) == ('f' as i32)) as i32) != 0));
     assert!(((((arr[(3) as usize] as i32) == ('b' as i32)) as i32) != 0));
     assert!(((((arr[(5) as usize] as i32) == ('r' as i32)) as i32) != 0));
     assert!(((((arr[(6) as usize] as i32) == ('\0' as i32)) as i32) != 0));
-    let mut split_pieces: *const u8 = (b"abcdefghi\0".as_ptr().cast_mut()).cast_const();
+    let mut split_pieces: *const libc::c_char = (c"abcdefghi".as_ptr().cast_mut()).cast_const();
     assert!((((((*split_pieces.offset((0) as isize)) as i32) == ('a' as i32)) as i32) != 0));
     assert!((((((*split_pieces.offset((3) as isize)) as i32) == ('d' as i32)) as i32) != 0));
     assert!((((((*split_pieces.offset((6) as isize)) as i32) == ('g' as i32)) as i32) != 0));
diff --git a/tests/unit/out/unsafe/string_literals_return.rs b/tests/unit/out/unsafe/string_literals_return.rs
index ee7ae6fa..c58b2a68 100644
--- a/tests/unit/out/unsafe/string_literals_return.rs
+++ b/tests/unit/out/unsafe/string_literals_return.rs
@@ -6,17 +6,17 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn get_greeting_0() -> *const u8 {
-    return b"hello\0".as_ptr();
+pub unsafe fn get_greeting_0() -> *const libc::c_char {
+    return c"hello".as_ptr();
 }
-pub unsafe fn get_empty_1() -> *const u8 {
-    return b"\0".as_ptr();
+pub unsafe fn get_empty_1() -> *const libc::c_char {
+    return c"".as_ptr();
 }
-pub unsafe fn get_branch_2(mut x: i32) -> *const u8 {
+pub unsafe fn get_branch_2(mut x: i32) -> *const libc::c_char {
     if ((x) > (0)) {
-        return b"positive\0".as_ptr();
+        return c"positive".as_ptr();
     }
-    return b"non-positive\0".as_ptr();
+    return c"non-positive".as_ptr();
 }
 pub fn main() {
     unsafe {
@@ -24,19 +24,19 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut a: *const u8 = (unsafe { get_greeting_0() });
-    assert!((((*a.offset((0) as isize)) as i32) == (('h' as u8) as i32)));
-    assert!((((*a.offset((4) as isize)) as i32) == (('o' as u8) as i32)));
-    assert!((((*a.offset((5) as isize)) as i32) == (('\0' as u8) as i32)));
-    let mut b: *const u8 = (unsafe { get_empty_1() });
-    assert!((((*b.offset((0) as isize)) as i32) == (('\0' as u8) as i32)));
-    let mut c: *const u8 = (unsafe { get_branch_2(1) });
-    assert!((((*c.offset((0) as isize)) as i32) == (('p' as u8) as i32)));
-    assert!((((*c.offset((7) as isize)) as i32) == (('e' as u8) as i32)));
-    assert!((((*c.offset((8) as isize)) as i32) == (('\0' as u8) as i32)));
-    let mut d: *const u8 = (unsafe { get_branch_2(-1_i32) });
-    assert!((((*d.offset((0) as isize)) as i32) == (('n' as u8) as i32)));
-    assert!((((*d.offset((11) as isize)) as i32) == (('e' as u8) as i32)));
-    assert!((((*d.offset((12) as isize)) as i32) == (('\0' as u8) as i32)));
+    let mut a: *const libc::c_char = (unsafe { get_greeting_0() });
+    assert!((((*a.offset((0) as isize)) as i32) == (('h' as libc::c_char) as i32)));
+    assert!((((*a.offset((4) as isize)) as i32) == (('o' as libc::c_char) as i32)));
+    assert!((((*a.offset((5) as isize)) as i32) == (('\0' as libc::c_char) as i32)));
+    let mut b: *const libc::c_char = (unsafe { get_empty_1() });
+    assert!((((*b.offset((0) as isize)) as i32) == (('\0' as libc::c_char) as i32)));
+    let mut c: *const libc::c_char = (unsafe { get_branch_2(1) });
+    assert!((((*c.offset((0) as isize)) as i32) == (('p' as libc::c_char) as i32)));
+    assert!((((*c.offset((7) as isize)) as i32) == (('e' as libc::c_char) as i32)));
+    assert!((((*c.offset((8) as isize)) as i32) == (('\0' as libc::c_char) as i32)));
+    let mut d: *const libc::c_char = (unsafe { get_branch_2(-1_i32) });
+    assert!((((*d.offset((0) as isize)) as i32) == (('n' as libc::c_char) as i32)));
+    assert!((((*d.offset((11) as isize)) as i32) == (('e' as libc::c_char) as i32)));
+    assert!((((*d.offset((12) as isize)) as i32) == (('\0' as libc::c_char) as i32)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/string_literals_return_c.rs b/tests/unit/out/unsafe/string_literals_return_c.rs
index 5e03b387..8380b35e 100644
--- a/tests/unit/out/unsafe/string_literals_return_c.rs
+++ b/tests/unit/out/unsafe/string_literals_return_c.rs
@@ -6,17 +6,17 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn get_greeting_0() -> *const u8 {
-    return (b"hello\0".as_ptr().cast_mut()).cast_const();
+pub unsafe fn get_greeting_0() -> *const libc::c_char {
+    return (c"hello".as_ptr().cast_mut()).cast_const();
 }
-pub unsafe fn get_empty_1() -> *const u8 {
-    return (b"\0".as_ptr().cast_mut()).cast_const();
+pub unsafe fn get_empty_1() -> *const libc::c_char {
+    return (c"".as_ptr().cast_mut()).cast_const();
 }
-pub unsafe fn get_branch_2(mut x: i32) -> *const u8 {
+pub unsafe fn get_branch_2(mut x: i32) -> *const libc::c_char {
     if ((((x) > (0)) as i32) != 0) {
-        return (b"positive\0".as_ptr().cast_mut()).cast_const();
+        return (c"positive".as_ptr().cast_mut()).cast_const();
     }
-    return (b"non-positive\0".as_ptr().cast_mut()).cast_const();
+    return (c"non-positive".as_ptr().cast_mut()).cast_const();
 }
 pub fn main() {
     unsafe {
@@ -24,17 +24,17 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut a: *const u8 = (unsafe { get_greeting_0() });
+    let mut a: *const libc::c_char = (unsafe { get_greeting_0() });
     assert!((((((*a.offset((0) as isize)) as i32) == ('h' as i32)) as i32) != 0));
     assert!((((((*a.offset((4) as isize)) as i32) == ('o' as i32)) as i32) != 0));
     assert!((((((*a.offset((5) as isize)) as i32) == ('\0' as i32)) as i32) != 0));
-    let mut b: *const u8 = (unsafe { get_empty_1() });
+    let mut b: *const libc::c_char = (unsafe { get_empty_1() });
     assert!((((((*b.offset((0) as isize)) as i32) == ('\0' as i32)) as i32) != 0));
-    let mut c: *const u8 = (unsafe { get_branch_2(1) });
+    let mut c: *const libc::c_char = (unsafe { get_branch_2(1) });
     assert!((((((*c.offset((0) as isize)) as i32) == ('p' as i32)) as i32) != 0));
     assert!((((((*c.offset((7) as isize)) as i32) == ('e' as i32)) as i32) != 0));
     assert!((((((*c.offset((8) as isize)) as i32) == ('\0' as i32)) as i32) != 0));
-    let mut d: *const u8 = (unsafe { get_branch_2(-1_i32) });
+    let mut d: *const libc::c_char = (unsafe { get_branch_2(-1_i32) });
     assert!((((((*d.offset((0) as isize)) as i32) == ('n' as i32)) as i32) != 0));
     assert!((((((*d.offset((11) as isize)) as i32) == ('e' as i32)) as i32) != 0));
     assert!((((((*d.offset((12) as isize)) as i32) == ('\0' as i32)) as i32) != 0));
diff --git a/tests/unit/out/unsafe/string_literals_sized.rs b/tests/unit/out/unsafe/string_literals_sized.rs
index eec42f0f..2e67b581 100644
--- a/tests/unit/out/unsafe/string_literals_sized.rs
+++ b/tests/unit/out/unsafe/string_literals_sized.rs
@@ -12,26 +12,32 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut empty_buf: [u8; 256] = [0u8; 256];
-    assert!(((empty_buf[(0) as usize] as i32) == (('\0' as u8) as i32)));
-    assert!(((empty_buf[(255) as usize] as i32) == (('\0' as u8) as i32)));
-    let mut prefix_buf: [u8; 32] =
-        *b"%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
-    assert!(((prefix_buf[(0) as usize] as i32) == (('%' as u8) as i32)));
-    assert!(((prefix_buf[(1) as usize] as i32) == (('\0' as u8) as i32)));
-    assert!(((prefix_buf[(31) as usize] as i32) == (('\0' as u8) as i32)));
-    let mut short_buf: [u8; 16] = *b"hi\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
-    assert!(((short_buf[(0) as usize] as i32) == (('h' as u8) as i32)));
-    assert!(((short_buf[(1) as usize] as i32) == (('i' as u8) as i32)));
-    assert!(((short_buf[(2) as usize] as i32) == (('\0' as u8) as i32)));
-    assert!(((short_buf[(15) as usize] as i32) == (('\0' as u8) as i32)));
-    let mut exact_buf: [u8; 6] = *b"hello\0";
-    assert!(((exact_buf[(0) as usize] as i32) == (('h' as u8) as i32)));
-    assert!(((exact_buf[(4) as usize] as i32) == (('o' as u8) as i32)));
-    assert!(((exact_buf[(5) as usize] as i32) == (('\0' as u8) as i32)));
-    assert!(((::std::mem::size_of::<[u8; 6]>()) == (6_usize)));
-    assert!((((::std::mem::size_of::<[u8; 6]>() as usize).wrapping_sub(1_usize)) == (5_usize)));
-    assert!(((::std::mem::size_of::<[u8; 1]>()) == (1_usize)));
-    assert!((((::std::mem::size_of::<[u8; 16]>() as usize).wrapping_sub(1_usize)) == (15_usize)));
+    let mut empty_buf: [libc::c_char; 256] = [0 as libc::c_char; 256];
+    assert!(((empty_buf[(0) as usize] as i32) == (('\0' as libc::c_char) as i32)));
+    assert!(((empty_buf[(255) as usize] as i32) == (('\0' as libc::c_char) as i32)));
+    let mut prefix_buf: [libc::c_char; 32] =
+        std::mem::transmute(*b"%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
+    assert!(((prefix_buf[(0) as usize] as i32) == (('%' as libc::c_char) as i32)));
+    assert!(((prefix_buf[(1) as usize] as i32) == (('\0' as libc::c_char) as i32)));
+    assert!(((prefix_buf[(31) as usize] as i32) == (('\0' as libc::c_char) as i32)));
+    let mut short_buf: [libc::c_char; 16] = std::mem::transmute(*b"hi\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
+    assert!(((short_buf[(0) as usize] as i32) == (('h' as libc::c_char) as i32)));
+    assert!(((short_buf[(1) as usize] as i32) == (('i' as libc::c_char) as i32)));
+    assert!(((short_buf[(2) as usize] as i32) == (('\0' as libc::c_char) as i32)));
+    assert!(((short_buf[(15) as usize] as i32) == (('\0' as libc::c_char) as i32)));
+    let mut exact_buf: [libc::c_char; 6] = std::mem::transmute(*b"hello\0");
+    assert!(((exact_buf[(0) as usize] as i32) == (('h' as libc::c_char) as i32)));
+    assert!(((exact_buf[(4) as usize] as i32) == (('o' as libc::c_char) as i32)));
+    assert!(((exact_buf[(5) as usize] as i32) == (('\0' as libc::c_char) as i32)));
+    assert!(((::std::mem::size_of::<[libc::c_char; 6]>()) == (6_usize)));
+    assert!(
+        (((::std::mem::size_of::<[libc::c_char; 6]>() as usize).wrapping_sub(1_usize))
+            == (5_usize))
+    );
+    assert!(((::std::mem::size_of::<[libc::c_char; 1]>()) == (1_usize)));
+    assert!(
+        (((::std::mem::size_of::<[libc::c_char; 16]>() as usize).wrapping_sub(1_usize))
+            == (15_usize))
+    );
     return 0;
 }
diff --git a/tests/unit/out/unsafe/string_literals_sized_c.rs b/tests/unit/out/unsafe/string_literals_sized_c.rs
index 61022fc6..8d8a6190 100644
--- a/tests/unit/out/unsafe/string_literals_sized_c.rs
+++ b/tests/unit/out/unsafe/string_literals_sized_c.rs
@@ -12,33 +12,33 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut empty_buf: [u8; 256] = [0u8; 256];
+    let mut empty_buf: [libc::c_char; 256] = [0 as libc::c_char; 256];
     assert!(((((empty_buf[(0) as usize] as i32) == ('\0' as i32)) as i32) != 0));
     assert!(((((empty_buf[(255) as usize] as i32) == ('\0' as i32)) as i32) != 0));
-    let mut prefix_buf: [u8; 32] =
-        *b"%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+    let mut prefix_buf: [libc::c_char; 32] =
+        std::mem::transmute(*b"%\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
     assert!(((((prefix_buf[(0) as usize] as i32) == ('%' as i32)) as i32) != 0));
     assert!(((((prefix_buf[(1) as usize] as i32) == ('\0' as i32)) as i32) != 0));
     assert!(((((prefix_buf[(31) as usize] as i32) == ('\0' as i32)) as i32) != 0));
-    let mut short_buf: [u8; 16] = *b"hi\0\0\0\0\0\0\0\0\0\0\0\0\0\0";
+    let mut short_buf: [libc::c_char; 16] = std::mem::transmute(*b"hi\0\0\0\0\0\0\0\0\0\0\0\0\0\0");
     assert!(((((short_buf[(0) as usize] as i32) == ('h' as i32)) as i32) != 0));
     assert!(((((short_buf[(1) as usize] as i32) == ('i' as i32)) as i32) != 0));
     assert!(((((short_buf[(2) as usize] as i32) == ('\0' as i32)) as i32) != 0));
     assert!(((((short_buf[(15) as usize] as i32) == ('\0' as i32)) as i32) != 0));
-    let mut exact_buf: [u8; 6] = *b"hello\0";
+    let mut exact_buf: [libc::c_char; 6] = std::mem::transmute(*b"hello\0");
     assert!(((((exact_buf[(0) as usize] as i32) == ('h' as i32)) as i32) != 0));
     assert!(((((exact_buf[(4) as usize] as i32) == ('o' as i32)) as i32) != 0));
     assert!(((((exact_buf[(5) as usize] as i32) == ('\0' as i32)) as i32) != 0));
-    assert!(((((::std::mem::size_of::<[u8; 6]>()) == (6_usize)) as i32) != 0));
+    assert!(((((::std::mem::size_of::<[libc::c_char; 6]>()) == (6_usize)) as i32) != 0));
     assert!(
-        (((((::std::mem::size_of::<[u8; 6]>() as usize).wrapping_sub(1_usize)) == (5_usize))
-            as i32)
+        (((((::std::mem::size_of::<[libc::c_char; 6]>() as usize).wrapping_sub(1_usize))
+            == (5_usize)) as i32)
             != 0)
     );
-    assert!(((((::std::mem::size_of::<[u8; 1]>()) == (1_usize)) as i32) != 0));
+    assert!(((((::std::mem::size_of::<[libc::c_char; 1]>()) == (1_usize)) as i32) != 0));
     assert!(
-        (((((::std::mem::size_of::<[u8; 16]>() as usize).wrapping_sub(1_usize)) == (15_usize))
-            as i32)
+        (((((::std::mem::size_of::<[libc::c_char; 16]>() as usize).wrapping_sub(1_usize))
+            == (15_usize)) as i32)
             != 0)
     );
     return 0;
diff --git a/tests/unit/out/unsafe/strlen.rs b/tests/unit/out/unsafe/strlen.rs
index df369b68..8e60dde2 100644
--- a/tests/unit/out/unsafe/strlen.rs
+++ b/tests/unit/out/unsafe/strlen.rs
@@ -6,9 +6,9 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn strlen_0(mut ptr: *mut u8) -> u32 {
+pub unsafe fn strlen_0(mut ptr: *mut libc::c_char) -> u32 {
     let mut count: u32 = 0_u32;
-    'loop_: while (((*ptr.postfix_inc()) as i32) != (('\0' as u8) as i32)) {
+    'loop_: while (((*ptr.postfix_inc()) as i32) != (('\0' as libc::c_char) as i32)) {
         count.prefix_inc();
     }
     return count;
@@ -19,13 +19,13 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut string: [u8; 6] = [
-        ('h' as u8),
-        ('e' as u8),
-        ('l' as u8),
-        ('l' as u8),
-        ('o' as u8),
-        ('\0' as u8),
+    let mut string: [libc::c_char; 6] = [
+        ('h' as libc::c_char),
+        ('e' as libc::c_char),
+        ('l' as libc::c_char),
+        ('l' as libc::c_char),
+        ('o' as libc::c_char),
+        ('\0' as libc::c_char),
     ];
-    return ((unsafe { strlen_0((&mut string[(0) as usize] as *mut u8)) }) as i32);
+    return ((unsafe { strlen_0((&mut string[(0) as usize] as *mut libc::c_char)) }) as i32);
 }
diff --git a/tests/unit/out/unsafe/strlen_diff.rs b/tests/unit/out/unsafe/strlen_diff.rs
index 3afe084a..852674b5 100644
--- a/tests/unit/out/unsafe/strlen_diff.rs
+++ b/tests/unit/out/unsafe/strlen_diff.rs
@@ -6,12 +6,13 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn strlen_0(mut s: *const u8) -> usize {
-    let mut begin: *const u8 = s;
+pub unsafe fn strlen_0(mut s: *const libc::c_char) -> usize {
+    let mut begin: *const libc::c_char = s;
     'loop_: while ((*s) != 0) {
         s.prefix_inc();
     }
-    return ((((s as usize - begin as usize) / ::std::mem::size_of::<u8>()) as i64) as usize);
+    return ((((s as usize - begin as usize) / ::std::mem::size_of::<libc::c_char>()) as i64)
+        as usize);
 }
 pub fn main() {
     unsafe {
@@ -19,14 +20,14 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let s: [u8; 7] = [
-        ('s' as u8),
-        ('t' as u8),
-        ('r' as u8),
-        ('i' as u8),
-        ('n' as u8),
-        ('g' as u8),
-        ('\0' as u8),
+    let s: [libc::c_char; 7] = [
+        ('s' as libc::c_char),
+        ('t' as libc::c_char),
+        ('r' as libc::c_char),
+        ('i' as libc::c_char),
+        ('n' as libc::c_char),
+        ('g' as libc::c_char),
+        ('\0' as libc::c_char),
     ];
-    return ((unsafe { strlen_0((&s[(0) as usize] as *const u8)) }) as i32);
+    return ((unsafe { strlen_0((&s[(0) as usize] as *const libc::c_char)) }) as i32);
 }
diff --git a/tests/unit/out/unsafe/strlen_rec.rs b/tests/unit/out/unsafe/strlen_rec.rs
index 37efcb23..dc93d293 100644
--- a/tests/unit/out/unsafe/strlen_rec.rs
+++ b/tests/unit/out/unsafe/strlen_rec.rs
@@ -6,7 +6,7 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn strlen_0(mut s: *const u8, mut n: i32) -> i32 {
+pub unsafe fn strlen_0(mut s: *const libc::c_char, mut n: i32) -> i32 {
     return if ((*s) != 0) {
         (unsafe { strlen_0(s.offset((1) as isize), ((n) + (1))) })
     } else {
@@ -19,6 +19,11 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let s: [u8; 4] = [('s' as u8), ('t' as u8), ('r' as u8), ('\0' as u8)];
-    return (unsafe { strlen_0((&s[(0) as usize] as *const u8), 0) });
+    let s: [libc::c_char; 4] = [
+        ('s' as libc::c_char),
+        ('t' as libc::c_char),
+        ('r' as libc::c_char),
+        ('\0' as libc::c_char),
+    ];
+    return (unsafe { strlen_0((&s[(0) as usize] as *const libc::c_char), 0) });
 }
diff --git a/tests/unit/out/unsafe/struct_default_ctor.rs b/tests/unit/out/unsafe/struct_default_ctor.rs
index 435e0682..cd25e3d5 100644
--- a/tests/unit/out/unsafe/struct_default_ctor.rs
+++ b/tests/unit/out/unsafe/struct_default_ctor.rs
@@ -9,7 +9,7 @@ use std::rc::Rc;
 #[repr(C)]
 #[derive(Clone)]
 pub struct WOFF2Params {
-    pub extended_metadata: Vec<u8>,
+    pub extended_metadata: Vec<libc::c_char>,
     pub brotli_quality: i32,
     pub allow_transforms: bool,
 }
@@ -17,7 +17,7 @@ impl WOFF2Params {
     pub unsafe fn WOFF2Params() -> Self {
         let mut this = Self {
             extended_metadata: {
-                let s = b"\0".as_ptr();
+                let s = c"".as_ptr();
                 std::slice::from_raw_parts(s, (0..).take_while(|&i| *s.add(i) != 0).count() + 1)
                     .to_vec()
             },
diff --git a/tests/unit/out/unsafe/switch_char.rs b/tests/unit/out/unsafe/switch_char.rs
index bccb5ee2..b35a0115 100644
--- a/tests/unit/out/unsafe/switch_char.rs
+++ b/tests/unit/out/unsafe/switch_char.rs
@@ -6,20 +6,20 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn switch_char_0(mut c: u8) -> i32 {
+pub unsafe fn switch_char_0(mut c: libc::c_char) -> i32 {
     'switch: {
         let __match_cond = (c as i32);
         match __match_cond {
-            __v if __v == (('a' as u8) as i32) => {
+            __v if __v == (('a' as libc::c_char) as i32) => {
                 return 1;
             }
-            __v if __v == (('b' as u8) as i32) => {
+            __v if __v == (('b' as libc::c_char) as i32) => {
                 return 2;
             }
-            __v if __v == (('\n' as u8) as i32) => {
+            __v if __v == (('\n' as libc::c_char) as i32) => {
                 return 3;
             }
-            __v if __v == (('\0' as u8) as i32) => {
+            __v if __v == (('\0' as libc::c_char) as i32) => {
                 return 4;
             }
             _ => {
@@ -53,10 +53,10 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    assert!(((unsafe { switch_char_0(('a' as u8),) }) == (1)));
-    assert!(((unsafe { switch_char_0(('b' as u8),) }) == (2)));
-    assert!(((unsafe { switch_char_0(('\n' as u8),) }) == (3)));
-    assert!(((unsafe { switch_char_0(('\0' as u8),) }) == (4)));
-    assert!(((unsafe { switch_char_0(('z' as u8),) }) == (0)));
+    assert!(((unsafe { switch_char_0(('a' as libc::c_char),) }) == (1)));
+    assert!(((unsafe { switch_char_0(('b' as libc::c_char),) }) == (2)));
+    assert!(((unsafe { switch_char_0(('\n' as libc::c_char),) }) == (3)));
+    assert!(((unsafe { switch_char_0(('\0' as libc::c_char),) }) == (4)));
+    assert!(((unsafe { switch_char_0(('z' as libc::c_char),) }) == (0)));
     return 0;
 }
diff --git a/tests/unit/out/unsafe/sys_stat.rs b/tests/unit/out/unsafe/sys_stat.rs
index 6094a5fd..89445d13 100644
--- a/tests/unit/out/unsafe/sys_stat.rs
+++ b/tests/unit/out/unsafe/sys_stat.rs
@@ -7,34 +7,24 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn test_stat_0() {
-    let mut path: *const u8 = (b"/tmp/cpp2rust_stat_test.tmp\0".as_ptr().cast_mut()).cast_const();
-    let mut fp: *mut ::libc::FILE = libc::fopen(
-        path as *const i8,
-        (b"wb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    let mut path: *const libc::c_char =
+        (c"/tmp/cpp2rust_stat_test.tmp".as_ptr().cast_mut()).cast_const();
+    let mut fp: *mut ::libc::FILE = libc::fopen(path, (c"wb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
-    libc::fputs(
-        (b"hello\0".as_ptr().cast_mut()).cast_const() as *const i8,
-        fp,
-    );
+    libc::fputs((c"hello".as_ptr().cast_mut()).cast_const(), fp);
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
     let mut st: stat = unsafe { std::mem::zeroed::<stat>() };
-    assert!(((((libc::stat(path as *const i8, (&mut st as *mut stat))) == (0)) as i32) != 0));
+    assert!(((((libc::stat(path, (&mut st as *mut stat))) == (0)) as i32) != 0));
     assert!(((((st.st_size) == (5_i64)) as i32) != 0));
     assert!(((((st.st_mtime) > (0_i64)) as i32) != 0));
-    libc::unlink(path as *const i8);
+    libc::unlink(path);
 }
 pub unsafe fn test_fstat_1() {
-    let mut path: *const u8 = (b"/tmp/cpp2rust_fstat_test.tmp\0".as_ptr().cast_mut()).cast_const();
-    let mut fp: *mut ::libc::FILE = libc::fopen(
-        path as *const i8,
-        (b"wb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    let mut path: *const libc::c_char =
+        (c"/tmp/cpp2rust_fstat_test.tmp".as_ptr().cast_mut()).cast_const();
+    let mut fp: *mut ::libc::FILE = libc::fopen(path, (c"wb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
-    libc::fputs(
-        (b"hello world\0".as_ptr().cast_mut()).cast_const() as *const i8,
-        fp,
-    );
+    libc::fputs((c"hello world".as_ptr().cast_mut()).cast_const(), fp);
     libc::fflush(fp);
     let mut fd: i32 = libc::fileno(fp);
     let mut st: stat = unsafe { std::mem::zeroed::<stat>() };
@@ -42,7 +32,7 @@ pub unsafe fn test_fstat_1() {
     assert!(((((st.st_size) == (11_i64)) as i32) != 0));
     assert!(((((st.st_mtime) > (0_i64)) as i32) != 0));
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
-    libc::unlink(path as *const i8);
+    libc::unlink(path);
 }
 pub fn main() {
     unsafe {
diff --git a/tests/unit/out/unsafe/union_addrof_external.rs b/tests/unit/out/unsafe/union_addrof_external.rs
index 416a6101..b4cbb9f9 100644
--- a/tests/unit/out/unsafe/union_addrof_external.rs
+++ b/tests/unit/out/unsafe/union_addrof_external.rs
@@ -12,7 +12,7 @@ pub struct record {
     pub code: u16,
     pub lo: u16,
     pub hi: u32,
-    pub pad: [u8; 8],
+    pub pad: [libc::c_char; 8],
 }
 impl Default for record {
     fn default() -> Self {
@@ -20,7 +20,7 @@ impl Default for record {
             code: 0_u16,
             lo: 0_u16,
             hi: 0_u32,
-            pad: [0_u8; 8],
+            pad: [(0 as libc::c_char); 8],
         }
     }
 }
@@ -28,7 +28,7 @@ impl Default for record {
 #[derive(Copy, Clone)]
 pub union anon_0 {
     pub h: record,
-    pub raw_: [u8; 128],
+    pub raw_: [libc::c_char; 128],
 }
 impl Default for anon_0 {
     fn default() -> Self {
diff --git a/tests/unit/out/unsafe/union_cross_arm_cast.rs b/tests/unit/out/unsafe/union_cross_arm_cast.rs
index e37404af..eaf74bb9 100644
--- a/tests/unit/out/unsafe/union_cross_arm_cast.rs
+++ b/tests/unit/out/unsafe/union_cross_arm_cast.rs
@@ -10,13 +10,13 @@ use std::rc::Rc;
 #[derive(Copy, Clone)]
 pub struct shape_a {
     pub code: u16,
-    pub pad: [u8; 14],
+    pub pad: [libc::c_char; 14],
 }
 impl Default for shape_a {
     fn default() -> Self {
         shape_a {
             code: 0_u16,
-            pad: [0_u8; 14],
+            pad: [(0 as libc::c_char); 14],
         }
     }
 }
@@ -45,7 +45,7 @@ impl Default for shape_b {
 pub union anon_0 {
     pub a: shape_a,
     pub b: shape_b,
-    pub raw_: [u8; 64],
+    pub raw_: [libc::c_char; 64],
 }
 impl Default for anon_0 {
     fn default() -> Self {
@@ -81,13 +81,13 @@ unsafe fn main_0() -> i32 {
     assert!(((((c.u.b.code as i32) == (10)) as i32) != 0));
     c.u.b.lo = 8080_u16;
     assert!(
-        (((((*((&mut c.u.raw_ as *mut [u8; 64]) as *mut u8).offset((2) as isize)) as i32) == (144))
-            as i32)
+        (((((*((&mut c.u.raw_ as *mut [libc::c_char; 64]) as *mut u8).offset((2) as isize)) as i32)
+            == (144)) as i32)
             != 0)
     );
     assert!(
-        (((((*((&mut c.u.raw_ as *mut [u8; 64]) as *mut u8).offset((3) as isize)) as i32) == (31))
-            as i32)
+        (((((*((&mut c.u.raw_ as *mut [libc::c_char; 64]) as *mut u8).offset((3) as isize)) as i32)
+            == (31)) as i32)
             != 0)
     );
     return 0;
diff --git a/tests/unit/out/unsafe/union_memset_memcpy.rs b/tests/unit/out/unsafe/union_memset_memcpy.rs
index a5941c1d..c4801741 100644
--- a/tests/unit/out/unsafe/union_memset_memcpy.rs
+++ b/tests/unit/out/unsafe/union_memset_memcpy.rs
@@ -10,13 +10,13 @@ use std::rc::Rc;
 #[derive(Copy, Clone)]
 pub struct shape_a {
     pub code: u16,
-    pub pad: [u8; 14],
+    pub pad: [libc::c_char; 14],
 }
 impl Default for shape_a {
     fn default() -> Self {
         shape_a {
             code: 0_u16,
-            pad: [0_u8; 14],
+            pad: [(0 as libc::c_char); 14],
         }
     }
 }
@@ -26,7 +26,7 @@ pub struct shape_b {
     pub code: u16,
     pub lo: u16,
     pub hi: u32,
-    pub fill: [u8; 8],
+    pub fill: [libc::c_char; 8],
 }
 impl Default for shape_b {
     fn default() -> Self {
@@ -34,7 +34,7 @@ impl Default for shape_b {
             code: 0_u16,
             lo: 0_u16,
             hi: 0_u32,
-            fill: [0_u8; 8],
+            fill: [(0 as libc::c_char); 8],
         }
     }
 }
@@ -43,7 +43,7 @@ impl Default for shape_b {
 pub union anon_0 {
     pub a: shape_a,
     pub b: shape_b,
-    pub raw_: [u8; 256],
+    pub raw_: [libc::c_char; 256],
 }
 impl Default for anon_0 {
     fn default() -> Self {
@@ -86,16 +86,18 @@ unsafe fn main_0() -> i32 {
     src[(6) as usize] = 0_u8;
     src[(7) as usize] = 1_u8;
     let mut len: usize = 16_usize;
-    assert!(((((len) <= (::std::mem::size_of::<[u8; 256]>())) as i32) != 0));
+    assert!(((((len) <= (::std::mem::size_of::<[libc::c_char; 256]>())) as i32) != 0));
     {
         if len != 0 {
             ::std::ptr::copy_nonoverlapping(
                 (src.as_mut_ptr() as *const u8 as *const ::libc::c_void),
-                ((&mut c.view.raw_ as *mut [u8; 256]) as *mut [u8; 256] as *mut ::libc::c_void),
+                ((&mut c.view.raw_ as *mut [libc::c_char; 256]) as *mut [libc::c_char; 256]
+                    as *mut ::libc::c_void),
                 len as usize,
             )
         }
-        ((&mut c.view.raw_ as *mut [u8; 256]) as *mut [u8; 256] as *mut ::libc::c_void)
+        ((&mut c.view.raw_ as *mut [libc::c_char; 256]) as *mut [libc::c_char; 256]
+            as *mut ::libc::c_void)
     };
     assert!(((((c.view.b.code as i32) == (2)) as i32) != 0));
     assert!(
diff --git a/tests/unit/out/unsafe/union_nested.rs b/tests/unit/out/unsafe/union_nested.rs
index f1f6e1a1..4d16a9b0 100644
--- a/tests/unit/out/unsafe/union_nested.rs
+++ b/tests/unit/out/unsafe/union_nested.rs
@@ -10,13 +10,13 @@ use std::rc::Rc;
 #[derive(Copy, Clone)]
 pub struct record {
     pub code: u16,
-    pub pad: [u8; 14],
+    pub pad: [libc::c_char; 14],
 }
 impl Default for record {
     fn default() -> Self {
         record {
             code: 0_u16,
-            pad: [0_u8; 14],
+            pad: [(0 as libc::c_char); 14],
         }
     }
 }
@@ -24,7 +24,7 @@ impl Default for record {
 #[derive(Copy, Clone)]
 pub union anon_0 {
     pub h: record,
-    pub raw_: [u8; 128],
+    pub raw_: [libc::c_char; 128],
 }
 impl Default for anon_0 {
     fn default() -> Self {
@@ -75,7 +75,7 @@ unsafe fn main_0() -> i32 {
     ex.variant = 6;
     ex.len = (::std::mem::size_of::<record>() as u32);
     ex.body.h.code = 2_u16;
-    ex.body.h.pad[(0) as usize] = (('X' as i32) as u8);
+    ex.body.h.pad[(0) as usize] = (('X' as i32) as libc::c_char);
     assert!(((((ex.body.h.code as i32) == (2)) as i32) != 0));
     assert!(((((ex.body.h.pad[(0) as usize] as i32) == ('X' as i32)) as i32) != 0));
     assert!(((((ex.body.nested.view.h.code as i32) == (2)) as i32) != 0));
diff --git a/tests/unit/out/unsafe/union_struct_dual_use.rs b/tests/unit/out/unsafe/union_struct_dual_use.rs
index 16e65468..c392b62c 100644
--- a/tests/unit/out/unsafe/union_struct_dual_use.rs
+++ b/tests/unit/out/unsafe/union_struct_dual_use.rs
@@ -19,7 +19,7 @@ pub unsafe fn sum_inner_0(mut i: *mut Inner) -> i32 {
 #[derive(Copy, Clone)]
 pub union anon_1 {
     pub inner: Inner,
-    pub raw_: [u8; 16],
+    pub raw_: [libc::c_char; 16],
 }
 impl Default for anon_1 {
     fn default() -> Self {
diff --git a/tests/unit/out/unsafe/union_tagged_many_arms.rs b/tests/unit/out/unsafe/union_tagged_many_arms.rs
index 77c2d761..b4d450bc 100644
--- a/tests/unit/out/unsafe/union_tagged_many_arms.rs
+++ b/tests/unit/out/unsafe/union_tagged_many_arms.rs
@@ -31,7 +31,7 @@ libcc2rs::impl_enum_inc_dec!(Tag_enum);
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub union anon_0 {
-    pub text: *const u8,
+    pub text: *const libc::c_char,
     pub handle: *mut ::libc::c_void,
     pub signed_n: i64,
     pub unsigned_n: u64,
@@ -64,7 +64,7 @@ unsafe fn main_0() -> i32 {
     assert!(((((b.payload.unsigned_n) == (3735928559_u64)) as i32) != 0));
     let mut c: Slot = <Slot>::default();
     c.tag = Tag_enum::T_TEXT;
-    c.payload.text = (b"hello\0".as_ptr().cast_mut()).cast_const();
+    c.payload.text = (c"hello".as_ptr().cast_mut()).cast_const();
     assert!((((((*c.payload.text.offset((0) as isize)) as i32) == ('h' as i32)) as i32) != 0));
     let mut d: Slot = <Slot>::default();
     d.tag = Tag_enum::T_FLOAT;
diff --git a/tests/unit/out/unsafe/union_tagged_struct_arms.rs b/tests/unit/out/unsafe/union_tagged_struct_arms.rs
index 7c578e28..7f3ec388 100644
--- a/tests/unit/out/unsafe/union_tagged_struct_arms.rs
+++ b/tests/unit/out/unsafe/union_tagged_struct_arms.rs
@@ -27,7 +27,7 @@ libcc2rs::impl_enum_inc_dec!(Choice_enum);
 #[repr(C)]
 #[derive(Copy, Clone, Default)]
 pub struct anon_1 {
-    pub items: *mut *mut u8,
+    pub items: *mut *mut libc::c_char,
     pub count: i64,
     pub cursor: i64,
 }
@@ -73,11 +73,11 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    static mut items_4: [*mut u8; 3] = unsafe {
+    static mut items_4: [*mut libc::c_char; 3] = unsafe {
         [
-            b"a\0".as_ptr().cast_mut(),
-            b"b\0".as_ptr().cast_mut(),
-            b"c\0".as_ptr().cast_mut(),
+            c"a".as_ptr().cast_mut(),
+            c"b".as_ptr().cast_mut(),
+            c"c".as_ptr().cast_mut(),
         ]
     };;
     let mut p_list: Branch = <Branch>::default();
diff --git a/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs b/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
index 20a7b293..20bb762b 100644
--- a/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
+++ b/tests/unit/out/unsafe/union_void_ptr_sized_deref.rs
@@ -27,7 +27,7 @@ libcc2rs::impl_enum_inc_dec!(Width_enum);
 #[repr(C)]
 #[derive(Copy, Clone)]
 pub union anon_0 {
-    pub text: *const u8,
+    pub text: *const libc::c_char,
     pub handle: *mut ::libc::c_void,
     pub signed_n: i64,
     pub f: f64,
diff --git a/tests/unit/out/unsafe/unistd.rs b/tests/unit/out/unsafe/unistd.rs
index 90fac9bc..32e1adba 100644
--- a/tests/unit/out/unsafe/unistd.rs
+++ b/tests/unit/out/unsafe/unistd.rs
@@ -10,11 +10,11 @@ pub unsafe fn test_close_0() {
     let mut fds: [i32; 2] = [0_i32; 2];
     assert!(((((libc::pipe(fds.as_mut_ptr())) == (0)) as i32) != 0));
     assert!(((((libc::close(fds[(0) as usize])) == (0)) as i32) != 0));
-    let mut buf: [u8; 1] = [0_u8; 1];
+    let mut buf: [libc::c_char; 1] = [(0 as libc::c_char); 1];
     assert!(
         ((((libc::read(
             fds[(0) as usize],
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
             1_usize
         )) == (-1_i32 as isize)) as i32)
             != 0)
@@ -22,30 +22,31 @@ pub unsafe fn test_close_0() {
     assert!(((((libc::close(fds[(1) as usize])) == (0)) as i32) != 0));
 }
 pub unsafe fn test_lseek_1() {
-    let mut path: *const u8 = (b"/tmp/cpp2rust_lseek_test.tmp\0".as_ptr().cast_mut()).cast_const();
-    let mut fp: *mut ::libc::FILE = libc::fopen(
-        path as *const i8,
-        (b"wb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    let mut path: *const libc::c_char =
+        (c"/tmp/cpp2rust_lseek_test.tmp".as_ptr().cast_mut()).cast_const();
+    let mut fp: *mut ::libc::FILE = libc::fopen(path, (c"wb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
-    libc::fputs(
-        (b"hello world\0".as_ptr().cast_mut()).cast_const() as *const i8,
-        fp,
-    );
+    libc::fputs((c"hello world".as_ptr().cast_mut()).cast_const(), fp);
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
-    fp = libc::fopen(
-        path as *const i8,
-        (b"rb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    fp = libc::fopen(path, (c"rb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
     let mut fd: i32 = libc::fileno(fp);
     assert!(((((libc::lseek(fd, 0_i64, 2)) == (11_i64)) as i32) != 0));
     assert!(((((libc::lseek(fd, 6_i64, 0)) == (6_i64)) as i32) != 0));
-    let mut buf: [u8; 8] = [0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8];
+    let mut buf: [libc::c_char; 8] = [
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+    ];
     assert!(
         ((((libc::read(
             fd,
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
             5_usize
         )) == (5_isize)) as i32)
             != 0)
@@ -53,11 +54,12 @@ pub unsafe fn test_lseek_1() {
     assert!(
         (((({
             let sa = core::slice::from_raw_parts(
-                (buf.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 5_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (b"world\0".as_ptr().cast_mut() as *const u8 as *const ::libc::c_void) as *const u8,
+                (c"world".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void)
+                    as *const u8,
                 5_usize as usize,
             );
             let mut diff = 0_i32;
@@ -72,34 +74,40 @@ pub unsafe fn test_lseek_1() {
             != 0)
     );
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
-    libc::unlink(path as *const i8);
+    libc::unlink(path);
 }
 pub unsafe fn test_read_2() {
-    let mut path: *const u8 = (b"/tmp/cpp2rust_read_test.tmp\0".as_ptr().cast_mut()).cast_const();
-    let mut fp: *mut ::libc::FILE = libc::fopen(
-        path as *const i8,
-        (b"wb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    let mut path: *const libc::c_char =
+        (c"/tmp/cpp2rust_read_test.tmp".as_ptr().cast_mut()).cast_const();
+    let mut fp: *mut ::libc::FILE = libc::fopen(path, (c"wb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
-    libc::fputs(
-        (b"hello world\0".as_ptr().cast_mut()).cast_const() as *const i8,
-        fp,
-    );
+    libc::fputs((c"hello world".as_ptr().cast_mut()).cast_const(), fp);
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
-    fp = libc::fopen(
-        path as *const i8,
-        (b"rb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    fp = libc::fopen(path, (c"rb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
     let mut fd: i32 = libc::fileno(fp);
-    let mut buf: [u8; 16] = [
-        0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8,
-        0_u8,
+    let mut buf: [libc::c_char; 16] = [
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
     ];
     assert!(
         ((((libc::read(
             fd,
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
             16_usize
         )) == (11_isize)) as i32)
             != 0)
@@ -107,11 +115,11 @@ pub unsafe fn test_read_2() {
     assert!(
         (((({
             let sa = core::slice::from_raw_parts(
-                (buf.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 11_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (b"hello world\0".as_ptr().cast_mut() as *const u8 as *const ::libc::c_void)
+                (c"hello world".as_ptr().cast_mut() as *const libc::c_char as *const ::libc::c_void)
                     as *const u8,
                 11_usize as usize,
             );
@@ -127,36 +135,43 @@ pub unsafe fn test_read_2() {
             != 0)
     );
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
-    libc::unlink(path as *const i8);
+    libc::unlink(path);
 }
 pub unsafe fn test_unlink_3() {
-    let mut path: *const u8 = (b"/tmp/cpp2rust_unlink_test.tmp\0".as_ptr().cast_mut()).cast_const();
-    let mut fp: *mut ::libc::FILE = libc::fopen(
-        path as *const i8,
-        (b"wb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    let mut path: *const libc::c_char =
+        (c"/tmp/cpp2rust_unlink_test.tmp".as_ptr().cast_mut()).cast_const();
+    let mut fp: *mut ::libc::FILE = libc::fopen(path, (c"wb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
-    assert!(((((libc::unlink(path as *const i8)) == (0)) as i32) != 0));
-    assert!(((((libc::unlink(path as *const i8)) == (-1_i32)) as i32) != 0));
+    assert!(((((libc::unlink(path)) == (0)) as i32) != 0));
+    assert!(((((libc::unlink(path)) == (-1_i32)) as i32) != 0));
 }
 pub unsafe fn test_pipe_4() {
     let mut fds: [i32; 2] = [0_i32; 2];
     assert!(((((libc::pipe(fds.as_mut_ptr())) == (0)) as i32) != 0));
-    let mut msg: *const u8 = (b"world\0".as_ptr().cast_mut()).cast_const();
+    let mut msg: *const libc::c_char = (c"world".as_ptr().cast_mut()).cast_const();
     assert!(
         ((((libc::write(
             fds[(1) as usize],
-            (msg as *const u8 as *const ::libc::c_void),
+            (msg as *const libc::c_char as *const ::libc::c_void),
             5_usize
         )) == (5_isize)) as i32)
             != 0)
     );
-    let mut buf: [u8; 8] = [0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8, 0_u8];
+    let mut buf: [libc::c_char; 8] = [
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+        (0 as libc::c_char),
+    ];
     assert!(
         ((((libc::read(
             fds[(0) as usize],
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
             8_usize
         )) == (5_isize)) as i32)
             != 0)
@@ -164,11 +179,11 @@ pub unsafe fn test_pipe_4() {
     assert!(
         (((({
             let sa = core::slice::from_raw_parts(
-                (buf.as_mut_ptr() as *const u8 as *const ::libc::c_void) as *const u8,
+                (buf.as_mut_ptr() as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 5_usize as usize,
             );
             let sb = core::slice::from_raw_parts(
-                (msg as *const u8 as *const ::libc::c_void) as *const u8,
+                (msg as *const libc::c_char as *const ::libc::c_void) as *const u8,
                 5_usize as usize,
             );
             let mut diff = 0_i32;
@@ -186,7 +201,7 @@ pub unsafe fn test_pipe_4() {
     assert!(
         ((((libc::read(
             fds[(0) as usize],
-            (buf.as_mut_ptr() as *mut u8 as *mut ::libc::c_void),
+            (buf.as_mut_ptr() as *mut libc::c_char as *mut ::libc::c_void),
             8_usize
         )) == (0_isize)) as i32)
             != 0)
@@ -194,54 +209,45 @@ pub unsafe fn test_pipe_4() {
     assert!(((((libc::close(fds[(0) as usize])) == (0)) as i32) != 0));
 }
 pub unsafe fn test_ftruncate_5() {
-    let mut path: *const u8 =
-        (b"/tmp/cpp2rust_ftruncate_test.tmp\0".as_ptr().cast_mut()).cast_const();
-    let mut fp: *mut ::libc::FILE = libc::fopen(
-        path as *const i8,
-        (b"wb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    let mut path: *const libc::c_char =
+        (c"/tmp/cpp2rust_ftruncate_test.tmp".as_ptr().cast_mut()).cast_const();
+    let mut fp: *mut ::libc::FILE = libc::fopen(path, (c"wb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
-    libc::fputs(
-        (b"hello world\0".as_ptr().cast_mut()).cast_const() as *const i8,
-        fp,
-    );
+    libc::fputs((c"hello world".as_ptr().cast_mut()).cast_const(), fp);
     libc::fflush(fp);
     let mut fd: i32 = libc::fileno(fp);
     assert!(((((libc::ftruncate(fd, 5_i64)) == (0)) as i32) != 0));
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
-    fp = libc::fopen(
-        path as *const i8,
-        (b"rb\0".as_ptr().cast_mut()).cast_const() as *const i8,
-    );
+    fp = libc::fopen(path, (c"rb".as_ptr().cast_mut()).cast_const());
     assert!((((!((fp).is_null())) as i32) != 0));
     fd = (libc::fileno(fp)).clone();
     assert!(((((libc::lseek(fd, 0_i64, 2)) == (5_i64)) as i32) != 0));
     assert!(((((libc::fclose(fp)) == (0)) as i32) != 0));
-    libc::unlink(path as *const i8);
+    libc::unlink(path);
 }
 pub unsafe fn test_isatty_6() {
     printf(
-        (b"%d\n\0".as_ptr().cast_mut()).cast_const() as *const i8,
+        (c"%d\n".as_ptr().cast_mut()).cast_const() as *const i8,
         libc::isatty(0),
     );
 }
 pub unsafe fn test_geteuid_7() {
     printf(
-        (b"%u\n\0".as_ptr().cast_mut()).cast_const() as *const i8,
+        (c"%u\n".as_ptr().cast_mut()).cast_const() as *const i8,
         libc::geteuid(),
     );
 }
 pub unsafe fn test_gethostname_8() {
-    let mut name: [u8; 256] = [0_u8; 256];
+    let mut name: [libc::c_char; 256] = [(0 as libc::c_char); 256];
     assert!(
         ((((libc::gethostname(
-            name.as_mut_ptr() as *mut i8,
-            ::std::mem::size_of::<[u8; 256]>()
+            name.as_mut_ptr(),
+            ::std::mem::size_of::<[libc::c_char; 256]>()
         )) == (0)) as i32)
             != 0)
     );
     printf(
-        (b"%s\n\0".as_ptr().cast_mut()).cast_const() as *const i8,
+        (c"%s\n".as_ptr().cast_mut()).cast_const() as *const i8,
         name.as_mut_ptr(),
     );
 }
diff --git a/tests/unit/out/unsafe/user_defined_same_as_libc.rs b/tests/unit/out/unsafe/user_defined_same_as_libc.rs
index c793ca05..3fd2350f 100644
--- a/tests/unit/out/unsafe/user_defined_same_as_libc.rs
+++ b/tests/unit/out/unsafe/user_defined_same_as_libc.rs
@@ -6,7 +6,10 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn fopen_0(mut path: *const u8, mut mode: *const u8) -> *mut ::libc::FILE {
+pub unsafe fn fopen_0(
+    mut path: *const libc::c_char,
+    mut mode: *const libc::c_char,
+) -> *mut ::libc::FILE {
     &(path);
     &(mode);
     return std::ptr::null_mut();
@@ -19,8 +22,8 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     let mut fp: *mut ::libc::FILE = (unsafe {
         fopen_0(
-            (b"/tmp/irrelevant-file\0".as_ptr().cast_mut()).cast_const(),
-            (b"r\0".as_ptr().cast_mut()).cast_const(),
+            (c"/tmp/irrelevant-file".as_ptr().cast_mut()).cast_const(),
+            (c"r".as_ptr().cast_mut()).cast_const(),
         )
     });
     assert!(((((fp).is_null()) as i32) != 0));
diff --git a/tests/unit/out/unsafe/va_arg_conditional.rs b/tests/unit/out/unsafe/va_arg_conditional.rs
index 67f560db..1d302595 100644
--- a/tests/unit/out/unsafe/va_arg_conditional.rs
+++ b/tests/unit/out/unsafe/va_arg_conditional.rs
@@ -6,7 +6,11 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn conditional_log_0(mut verbose: i32, mut fmt: *const u8, __args: &[VaArg]) -> i32 {
+pub unsafe fn conditional_log_0(
+    mut verbose: i32,
+    mut fmt: *const libc::c_char,
+    __args: &[VaArg],
+) -> i32 {
     if (verbose != 0) {
         let mut ap: VaList = VaList::default();
         ap = VaList::new(__args);
@@ -23,21 +27,13 @@ pub fn main() {
 unsafe fn main_0() -> i32 {
     assert!(
         ((((unsafe {
-            conditional_log_0(
-                1,
-                (b"%d\0".as_ptr().cast_mut()).cast_const(),
-                &[(42).into()],
-            )
+            conditional_log_0(1, (c"%d".as_ptr().cast_mut()).cast_const(), &[(42).into()])
         }) == (42)) as i32)
             != 0)
     );
     assert!(
         ((((unsafe {
-            conditional_log_0(
-                0,
-                (b"%d\0".as_ptr().cast_mut()).cast_const(),
-                &[(99).into()],
-            )
+            conditional_log_0(0, (c"%d".as_ptr().cast_mut()).cast_const(), &[(99).into()])
         }) == (-1_i32)) as i32)
             != 0)
     );
diff --git a/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs b/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs
index 2876c26e..a51a1ff6 100644
--- a/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs
+++ b/tests/unit/out/unsafe/va_arg_non_primitive_ptrs.rs
@@ -40,8 +40,8 @@ pub unsafe fn dispatch_0(mut option: i32, __args: &[VaArg]) -> i32 {
         let __match_cond = option;
         match __match_cond {
             __v if __v == (opt::OPT_STRING_OUT as i32) => {
-                let mut out: *mut *const u8 = ap.arg::<*mut *const u8>();
-                (*out) = (b"hello\0".as_ptr().cast_mut()).cast_const();
+                let mut out: *mut *const libc::c_char = ap.arg::<*mut *const libc::c_char>();
+                (*out) = (c"hello".as_ptr().cast_mut()).cast_const();
                 result = 1;
                 break 'switch;
             }
@@ -72,12 +72,12 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut s: *const u8 = std::ptr::null();
+    let mut s: *const libc::c_char = std::ptr::null();
     assert!(
         ((((unsafe {
             dispatch_0(
                 (opt::OPT_STRING_OUT as i32),
-                &[(&mut s as *mut *const u8).into()],
+                &[(&mut s as *mut *const libc::c_char).into()],
             )
         }) == (1)) as i32)
             != 0)
diff --git a/tests/unit/out/unsafe/va_arg_printf.rs b/tests/unit/out/unsafe/va_arg_printf.rs
index ba50078b..59f1cfb0 100644
--- a/tests/unit/out/unsafe/va_arg_printf.rs
+++ b/tests/unit/out/unsafe/va_arg_printf.rs
@@ -6,11 +6,11 @@ use std::collections::BTreeMap;
 use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
-pub unsafe fn logf_impl_0(mut fmt: *const u8, mut ap: VaList) -> i32 {
+pub unsafe fn logf_impl_0(mut fmt: *const libc::c_char, mut ap: VaList) -> i32 {
     &(fmt);
     return ((ap.arg::<i32>()) + (ap.arg::<i32>()));
 }
-pub unsafe fn logf_1(mut fmt: *const u8, __args: &[VaArg]) -> i32 {
+pub unsafe fn logf_1(mut fmt: *const libc::c_char, __args: &[VaArg]) -> i32 {
     let mut ap: VaList = VaList::default();
     ap = VaList::new(__args);
     let mut result: i32 = (unsafe { logf_impl_0(fmt, ap) });
@@ -22,12 +22,12 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut dummy: *const u8 = (b"dummy\0".as_ptr().cast_mut()).cast_const();
+    let mut dummy: *const libc::c_char = (c"dummy".as_ptr().cast_mut()).cast_const();
     assert!(
         ((((unsafe {
             logf_1(
-                (b"hello %d %d\0".as_ptr().cast_mut()).cast_const(),
-                &[(10).into(), (libc::strlen(dummy as *const i8)).into()],
+                (c"hello %d %d".as_ptr().cast_mut()).cast_const(),
+                &[(10).into(), (libc::strlen(dummy)).into()],
             )
         }) == (15)) as i32)
             != 0)
@@ -35,7 +35,7 @@ unsafe fn main_0() -> i32 {
     assert!(
         ((((unsafe {
             logf_1(
-                (b"x %d %d\0".as_ptr().cast_mut()).cast_const(),
+                (c"x %d %d".as_ptr().cast_mut()).cast_const(),
                 &[(1).into(), (2).into()],
             )
         }) == (3)) as i32)
diff --git a/tests/unit/out/unsafe/va_arg_promotion.rs b/tests/unit/out/unsafe/va_arg_promotion.rs
index fca69dea..cda547f9 100644
--- a/tests/unit/out/unsafe/va_arg_promotion.rs
+++ b/tests/unit/out/unsafe/va_arg_promotion.rs
@@ -23,7 +23,7 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut x: u8 = (('A' as i32) as u8);
+    let mut x: libc::c_char = (('A' as i32) as libc::c_char);
     let mut y: i16 = 10_i16;
     let mut z: f32 = 3.0E+0;
     assert!(
diff --git a/tests/unit/out/unsafe/va_arg_snprintf.rs b/tests/unit/out/unsafe/va_arg_snprintf.rs
index 0134f56a..f9ea75f0 100644
--- a/tests/unit/out/unsafe/va_arg_snprintf.rs
+++ b/tests/unit/out/unsafe/va_arg_snprintf.rs
@@ -7,15 +7,15 @@ use std::io::{Read, Seek, Write};
 use std::os::fd::{AsFd, FromRawFd, IntoRawFd};
 use std::rc::Rc;
 pub unsafe fn extract_first_0(
-    mut buf: *mut u8,
+    mut buf: *mut libc::c_char,
     mut size: i32,
-    mut fmt: *const u8,
+    mut fmt: *const libc::c_char,
     __args: &[VaArg],
 ) -> i32 {
     let mut ap: VaList = VaList::default();
     ap = VaList::new(__args);
     let mut n: i32 = ap.arg::<i32>();
-    (*buf.offset((0) as isize)) = (n as u8);
+    (*buf.offset((0) as isize)) = (n as libc::c_char);
     return n;
 }
 pub fn main() {
@@ -24,13 +24,13 @@ pub fn main() {
     }
 }
 unsafe fn main_0() -> i32 {
-    let mut buf: [u8; 64] = [0_u8; 64];
+    let mut buf: [libc::c_char; 64] = [(0 as libc::c_char); 64];
     assert!(
         ((((unsafe {
             extract_first_0(
                 buf.as_mut_ptr(),
                 1,
-                (b"%d\0".as_ptr().cast_mut()).cast_const(),
+                (c"%d".as_ptr().cast_mut()).cast_const(),
                 &[(42).into()],
             )
         }) == (42)) as i32)
@@ -42,7 +42,7 @@ unsafe fn main_0() -> i32 {
             extract_first_0(
                 buf.as_mut_ptr(),
                 1,
-                (b"%d\0".as_ptr().cast_mut()).cast_const(),
+                (c"%d".as_ptr().cast_mut()).cast_const(),
                 &[(65).into()],
             )
         }) == (65)) as i32)
diff --git a/tests/unit/out/unsafe/va_arg_struct_ctx.rs b/tests/unit/out/unsafe/va_arg_struct_ctx.rs
index 1e8ff8ca..c70acdfb 100644
--- a/tests/unit/out/unsafe/va_arg_struct_ctx.rs
+++ b/tests/unit/out/unsafe/va_arg_struct_ctx.rs
@@ -12,7 +12,7 @@ pub struct context {
     pub verbose: i32,
     pub last_error: i32,
 }
-pub unsafe fn set_error_0(mut ctx: *mut context, mut fmt: *const u8, __args: &[VaArg]) {
+pub unsafe fn set_error_0(mut ctx: *mut context, mut fmt: *const libc::c_char, __args: &[VaArg]) {
     if ((*ctx).verbose != 0) {
         let mut ap: VaList = VaList::default();
         ap = VaList::new(__args);
@@ -31,7 +31,7 @@ unsafe fn main_0() -> i32 {
     (unsafe {
         set_error_0(
             (&mut ctx as *mut context),
-            (b"error %d\0".as_ptr().cast_mut()).cast_const(),
+            (c"error %d".as_ptr().cast_mut()).cast_const(),
             &[(42).into()],
         )
     });
@@ -40,7 +40,7 @@ unsafe fn main_0() -> i32 {
     (unsafe {
         set_error_0(
             (&mut ctx as *mut context),
-            (b"error %d\0".as_ptr().cast_mut()).cast_const(),
+            (c"error %d".as_ptr().cast_mut()).cast_const(),
             &[(99).into()],
         )
     });
diff --git a/tests/unit/out/unsafe/vector3.rs b/tests/unit/out/unsafe/vector3.rs
index c1f6ee06..d9573cb0 100644
--- a/tests/unit/out/unsafe/vector3.rs
+++ b/tests/unit/out/unsafe/vector3.rs
@@ -36,14 +36,14 @@ unsafe fn main_0() -> i32 {
         let mut v2 = v.as_mut_ptr().add(v2);
         'loop_: for i in 0..((*v2).len()) {
             let mut i = (&(*v2))[i].clone();
-            printf(b"%d\n\0".as_ptr() as *const i8, ((i) + (3)));
+            printf(c"%d\n".as_ptr() as *const i8, ((i) + (3)));
         }
     }
     'loop_: for v2 in 0..(v.len()) {
         let mut v2 = v[v2].clone();
         'loop_: for i in 0..(v2.len()) {
             let mut i = v2[i].clone();
-            printf(b"%d\n\0".as_ptr() as *const i8, i);
+            printf(c"%d\n".as_ptr() as *const i8, i);
         }
     }
     return 0;