mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Rollup merge of #113334 - fmease:revert-lexing-c-str-lits, r=compiler-errors

Browse Source 
Revert the lexing of `c"…"` string literals

Fixes \[after beta-backport\] #113235.
Further progress is tracked in #113333.

This PR *manually* reverts parts of #108801 (since a git-revert would've been too coarse-grained & messy)
and git-reverts #111647.

CC `@fee1-dead` (#108801) `@klensy` (#111647)
r? `@compiler-errors`

`@rustbot` label F-c_str_literals beta-nominated
This commit is contained in:
fee1-dead 2023-07-06 09:20:33 +08:00 committed by GitHub
commit 1830b80c2d
No known key found for this signature in database
GPG Key ID: 4AEE18F83AFDEB23
33 changed files with 221 additions and 100 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

11
Cargo.lock
View File

@ -766,6 +766,16 @@ dependencies = [
"typenum",
]
[[package]]
name = "cstr"
version = "0.2.8"
source = "registry+https://github.com/rust-lang/crates.io-index"
checksum = "c11a39d776a3b35896711da8a04dc1835169dcd36f710878187637314e47941b"
dependencies = [
"proc-macro2",
"quote",
]
[[package]]
name = "ctrlc"
version = "3.4.0"
@ -3016,6 +3026,7 @@ name = "rustc_codegen_llvm"
version = "0.0.0"
dependencies = [
"bitflags 1.3.2",
"cstr",
"libc",
"measureme",
"object",

1
compiler/rustc_codegen_llvm/Cargo.toml
View File

@ -8,6 +8,7 @@ test = false
[dependencies]
bitflags = "1.0"
cstr = "0.2"
libc = "0.2"
measureme = "10.0.0"
object = { version = "0.31.1", default-features = false, features = [

4
compiler/rustc_codegen_llvm/src/allocator.rs
View File

@ -77,7 +77,7 @@ pub(crate) unsafe fn codegen(
llvm::LLVMRustGetOrInsertFunction(llmod, callee.as_ptr().cast(), callee.len(), ty);
llvm::LLVMRustSetVisibility(callee, llvm::Visibility::Hidden);
let llbb = llvm::LLVMAppendBasicBlockInContext(llcx, llfn, c"entry".as_ptr().cast());
let llbb = llvm::LLVMAppendBasicBlockInContext(llcx, llfn, "entry\0".as_ptr().cast());
let llbuilder = llvm::LLVMCreateBuilderInContext(llcx);
llvm::LLVMPositionBuilderAtEnd(llbuilder, llbb);
@ -129,7 +129,7 @@ pub(crate) unsafe fn codegen(
attributes::apply_to_llfn(callee, llvm::AttributePlace::Function, &[no_return]);
llvm::LLVMRustSetVisibility(callee, llvm::Visibility::Hidden);
let llbb = llvm::LLVMAppendBasicBlockInContext(llcx, llfn, c"entry".as_ptr().cast());
let llbb = llvm::LLVMAppendBasicBlockInContext(llcx, llfn, "entry\0".as_ptr().cast());
let llbuilder = llvm::LLVMCreateBuilderInContext(llcx);
llvm::LLVMPositionBuilderAtEnd(llbuilder, llbb);

2
compiler/rustc_codegen_llvm/src/back/lto.rs
View File

@ -601,7 +601,7 @@ pub(crate) fn run_pass_manager(
llvm::LLVMRustAddModuleFlag(
module.module_llvm.llmod(),
llvm::LLVMModFlagBehavior::Error,
c"LTOPostLink".as_ptr().cast(),
"LTOPostLink\0".as_ptr().cast(),
1,
);
}

16
compiler/rustc_codegen_llvm/src/back/write.rs
View File

@ -931,16 +931,16 @@ unsafe fn embed_bitcode(
let llglobal = llvm::LLVMAddGlobal(
llmod,
common::val_ty(llconst),
c"rustc.embedded.module".as_ptr().cast(),
"rustc.embedded.module\0".as_ptr().cast(),
);
llvm::LLVMSetInitializer(llglobal, llconst);
let section = if is_apple {
c"__LLVM,__bitcode"
"__LLVM,__bitcode\0"
} else if is_aix {
c".ipa"
".ipa\0"
} else {
c".llvmbc"
".llvmbc\0"
};
llvm::LLVMSetSection(llglobal, section.as_ptr().cast());
llvm::LLVMRustSetLinkage(llglobal, llvm::Linkage::PrivateLinkage);
@ -950,15 +950,15 @@ unsafe fn embed_bitcode(
let llglobal = llvm::LLVMAddGlobal(
llmod,
common::val_ty(llconst),
c"rustc.embedded.cmdline".as_ptr().cast(),
"rustc.embedded.cmdline\0".as_ptr().cast(),
);
llvm::LLVMSetInitializer(llglobal, llconst);
let section = if is_apple {
c"__LLVM,__cmdline"
"__LLVM,__cmdline\0"
} else if is_aix {
c".info"
".info\0"
} else {
c".llvmcmd"
".llvmcmd\0"
};
llvm::LLVMSetSection(llglobal, section.as_ptr().cast());
llvm::LLVMRustSetLinkage(llglobal, llvm::Linkage::PrivateLinkage);

6
compiler/rustc_codegen_llvm/src/base.rs
View File

@ -19,6 +19,8 @@
use crate::llvm;
use crate::value::Value;
use cstr::cstr;
use rustc_codegen_ssa::base::maybe_create_entry_wrapper;
use rustc_codegen_ssa::mono_item::MonoItemExt;
use rustc_codegen_ssa::traits::*;
@ -108,11 +110,11 @@ fn module_codegen(tcx: TyCtxt<'_>, cgu_name: Symbol) -> ModuleCodegen<ModuleLlvm
// Create the llvm.used and llvm.compiler.used variables.
if !cx.used_statics.borrow().is_empty() {
cx.create_used_variable_impl(c"llvm.used", &*cx.used_statics.borrow());
cx.create_used_variable_impl(cstr!("llvm.used"), &*cx.used_statics.borrow());
}
if !cx.compiler_used_statics.borrow().is_empty() {
cx.create_used_variable_impl(
c"llvm.compiler.used",
cstr!("llvm.compiler.used"),
&*cx.compiler_used_statics.borrow(),
);
}

16
compiler/rustc_codegen_llvm/src/builder.rs
View File

@ -6,6 +6,7 @@
use crate::type_::Type;
use crate::type_of::LayoutLlvmExt;
use crate::value::Value;
use cstr::cstr;
use libc::{c_char, c_uint};
use rustc_codegen_ssa::common::{IntPredicate, RealPredicate, SynchronizationScope, TypeKind};
use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
@ -25,6 +26,7 @@
use rustc_target::spec::{HasTargetSpec, SanitizerSet, Target};
use smallvec::SmallVec;
use std::borrow::Cow;
use std::ffi::CStr;
use std::iter;
use std::ops::Deref;
use std::ptr;
@ -44,10 +46,13 @@ fn drop(&mut self) {
}
}
// FIXME(eddyb) use a checked constructor when they become `const fn`.
const EMPTY_C_STR: &CStr = unsafe { CStr::from_bytes_with_nul_unchecked(b"\0") };
/// Empty string, to be used where LLVM expects an instruction name, indicating
/// that the instruction is to be left unnamed (i.e. numbered, in textual IR).
// FIXME(eddyb) pass `&CStr` directly to FFI once it's a thin pointer.
const UNNAMED: *const c_char = c"".as_ptr();
const UNNAMED: *const c_char = EMPTY_C_STR.as_ptr();
impl<'ll, 'tcx> BackendTypes for Builder<'_, 'll, 'tcx> {
type Value = <CodegenCx<'ll, 'tcx> as BackendTypes>::Value;
@ -1002,13 +1007,14 @@ fn resume(&mut self, exn0: &'ll Value, exn1: &'ll Value) {
}
fn cleanup_pad(&mut self, parent: Option<&'ll Value>, args: &[&'ll Value]) -> Funclet<'ll> {
let name = cstr!("cleanuppad");
let ret = unsafe {
llvm::LLVMBuildCleanupPad(
self.llbuilder,
parent,
args.as_ptr(),
args.len() as c_uint,
c"cleanuppad".as_ptr(),
name.as_ptr(),
)
};
Funclet::new(ret.expect("LLVM does not have support for cleanuppad"))
@ -1022,13 +1028,14 @@ fn cleanup_ret(&mut self, funclet: &Funclet<'ll>, unwind: Option<&'ll BasicBlock
}
fn catch_pad(&mut self, parent: &'ll Value, args: &[&'ll Value]) -> Funclet<'ll> {
let name = cstr!("catchpad");
let ret = unsafe {
llvm::LLVMBuildCatchPad(
self.llbuilder,
parent,
args.as_ptr(),
args.len() as c_uint,
c"catchpad".as_ptr(),
name.as_ptr(),
)
};
Funclet::new(ret.expect("LLVM does not have support for catchpad"))
@ -1040,13 +1047,14 @@ fn catch_switch(
unwind: Option<&'ll BasicBlock>,
handlers: &[&'ll BasicBlock],
) -> &'ll Value {
let name = cstr!("catchswitch");
let ret = unsafe {
llvm::LLVMBuildCatchSwitch(
self.llbuilder,
parent,
unwind,
handlers.len() as c_uint,
c"catchswitch".as_ptr(),
name.as_ptr(),
)
};
let ret = ret.expect("LLVM does not have support for catchswitch");

7
compiler/rustc_codegen_llvm/src/consts.rs
View File

@ -8,6 +8,7 @@
use crate::type_::Type;
use crate::type_of::LayoutLlvmExt;
use crate::value::Value;
use cstr::cstr;
use rustc_codegen_ssa::traits::*;
use rustc_hir::def_id::DefId;
use rustc_middle::middle::codegen_fn_attrs::{CodegenFnAttrFlags, CodegenFnAttrs};
@ -481,9 +482,9 @@ fn codegen_static(&self, def_id: DefId, is_mutable: bool) {
.all(|&byte| byte == 0);
let sect_name = if all_bytes_are_zero {
c"__DATA,__thread_bss"
cstr!("__DATA,__thread_bss")
} else {
c"__DATA,__thread_data"
cstr!("__DATA,__thread_data")
};
llvm::LLVMSetSection(g, sect_name.as_ptr());
}
@ -512,7 +513,7 @@ fn codegen_static(&self, def_id: DefId, is_mutable: bool) {
let val = llvm::LLVMMetadataAsValue(self.llcx, meta);
llvm::LLVMAddNamedMetadataOperand(
self.llmod,
c"wasm.custom_sections".as_ptr().cast(),
"wasm.custom_sections\0".as_ptr().cast(),
val,
);
}

44
compiler/rustc_codegen_llvm/src/context.rs
View File

@ -8,6 +8,7 @@
use crate::type_::Type;
use crate::value::Value;
use cstr::cstr;
use rustc_codegen_ssa::base::{wants_msvc_seh, wants_wasm_eh};
use rustc_codegen_ssa::traits::*;
use rustc_data_structures::base_n;
@ -223,42 +224,36 @@ pub unsafe fn create_module<'ll>(
// If skipping the PLT is enabled, we need to add some module metadata
// to ensure intrinsic calls don't use it.
if !sess.needs_plt() {
llvm::LLVMRustAddModuleFlag(
llmod,
llvm::LLVMModFlagBehavior::Warning,
c"RtLibUseGOT".as_ptr().cast(),
1,
);
let avoid_plt = "RtLibUseGOT\0".as_ptr().cast();
llvm::LLVMRustAddModuleFlag(llmod, llvm::LLVMModFlagBehavior::Warning, avoid_plt, 1);
}
// Enable canonical jump tables if CFI is enabled. (See https://reviews.llvm.org/D65629.)
if sess.is_sanitizer_cfi_canonical_jump_tables_enabled() && sess.is_sanitizer_cfi_enabled() {
let canonical_jump_tables = "CFI Canonical Jump Tables\0".as_ptr().cast();
llvm::LLVMRustAddModuleFlag(
llmod,
llvm::LLVMModFlagBehavior::Override,
c"CFI Canonical Jump Tables".as_ptr().cast(),
canonical_jump_tables,
1,
);
}
// Enable LTO unit splitting if specified or if CFI is enabled. (See https://reviews.llvm.org/D53891.)
if sess.is_split_lto_unit_enabled() || sess.is_sanitizer_cfi_enabled() {
let enable_split_lto_unit = "EnableSplitLTOUnit\0".as_ptr().cast();
llvm::LLVMRustAddModuleFlag(
llmod,
llvm::LLVMModFlagBehavior::Override,
c"EnableSplitLTOUnit".as_ptr().cast(),
enable_split_lto_unit,
1,
);
}
// Add "kcfi" module flag if KCFI is enabled. (See https://reviews.llvm.org/D119296.)
if sess.is_sanitizer_kcfi_enabled() {
llvm::LLVMRustAddModuleFlag(
llmod,
llvm::LLVMModFlagBehavior::Override,
c"kcfi".as_ptr().cast(),
1,
);
let kcfi = "kcfi\0".as_ptr().cast();
llvm::LLVMRustAddModuleFlag(llmod, llvm::LLVMModFlagBehavior::Override, kcfi, 1);
}
// Control Flow Guard is currently only supported by the MSVC linker on Windows.
@ -270,7 +265,7 @@ pub unsafe fn create_module<'ll>(
llvm::LLVMRustAddModuleFlag(
llmod,
llvm::LLVMModFlagBehavior::Warning,
c"cfguard".as_ptr() as *const _,
"cfguard\0".as_ptr() as *const _,
1,
)
}
@ -279,7 +274,7 @@ pub unsafe fn create_module<'ll>(
llvm::LLVMRustAddModuleFlag(
llmod,
llvm::LLVMModFlagBehavior::Warning,
c"cfguard".as_ptr() as *const _,
"cfguard\0".as_ptr() as *const _,
2,
)
}
@ -297,26 +292,26 @@ pub unsafe fn create_module<'ll>(
llvm::LLVMRustAddModuleFlag(
llmod,
behavior,
c"branch-target-enforcement".as_ptr().cast(),
"branch-target-enforcement\0".as_ptr().cast(),
bti.into(),
);
llvm::LLVMRustAddModuleFlag(
llmod,
behavior,
c"sign-return-address".as_ptr().cast(),
"sign-return-address\0".as_ptr().cast(),
pac_ret.is_some().into(),
);
let pac_opts = pac_ret.unwrap_or(PacRet { leaf: false, key: PAuthKey::A });
llvm::LLVMRustAddModuleFlag(
llmod,
behavior,
c"sign-return-address-all".as_ptr().cast(),
"sign-return-address-all\0".as_ptr().cast(),
pac_opts.leaf.into(),
);
llvm::LLVMRustAddModuleFlag(
llmod,
behavior,
c"sign-return-address-with-bkey".as_ptr().cast(),
"sign-return-address-with-bkey\0".as_ptr().cast(),
u32::from(pac_opts.key == PAuthKey::B),
);
} else {
@ -332,7 +327,7 @@ pub unsafe fn create_module<'ll>(
llvm::LLVMRustAddModuleFlag(
llmod,
llvm::LLVMModFlagBehavior::Override,
c"cf-protection-branch".as_ptr().cast(),
"cf-protection-branch\0".as_ptr().cast(),
1,
)
}
@ -340,7 +335,7 @@ pub unsafe fn create_module<'ll>(
llvm::LLVMRustAddModuleFlag(
llmod,
llvm::LLVMModFlagBehavior::Override,
c"cf-protection-return".as_ptr().cast(),
"cf-protection-return\0".as_ptr().cast(),
1,
)
}
@ -349,7 +344,7 @@ pub unsafe fn create_module<'ll>(
llvm::LLVMRustAddModuleFlag(
llmod,
llvm::LLVMModFlagBehavior::Error,
c"Virtual Function Elim".as_ptr().cast(),
"Virtual Function Elim\0".as_ptr().cast(),
1,
);
}
@ -481,13 +476,14 @@ pub fn coverage_context(&self) -> Option<&coverageinfo::CrateCoverageContext<'ll
}
pub(crate) fn create_used_variable_impl(&self, name: &'static CStr, values: &[&'ll Value]) {
let section = cstr!("llvm.metadata");
let array = self.const_array(self.type_ptr_to(self.type_i8()), values);
unsafe {
let g = llvm::LLVMAddGlobal(self.llmod, self.val_ty(array), name.as_ptr());
llvm::LLVMSetInitializer(g, array);
llvm::LLVMRustSetLinkage(g, llvm::Linkage::AppendingLinkage);
llvm::LLVMSetSection(g, c"llvm.metadata".as_ptr());
llvm::LLVMSetSection(g, section.as_ptr());
}
}
}

3
compiler/rustc_codegen_llvm/src/debuginfo/gdb.rs
View File

@ -38,6 +38,7 @@ pub fn get_or_insert_gdb_debug_scripts_section_global<'ll>(cx: &CodegenCx<'ll, '
unsafe { llvm::LLVMGetNamedGlobal(cx.llmod, c_section_var_name.as_ptr().cast()) };
section_var.unwrap_or_else(|| {
let section_name = b".debug_gdb_scripts\0";
let mut section_contents = Vec::new();
// Add the pretty printers for the standard library first.
@ -70,7 +71,7 @@ pub fn get_or_insert_gdb_debug_scripts_section_global<'ll>(cx: &CodegenCx<'ll, '
let section_var = cx
.define_global(section_var_name, llvm_type)
.unwrap_or_else(|| bug!("symbol `{}` is already defined", section_var_name));
llvm::LLVMSetSection(section_var, c".debug_gdb_scripts".as_ptr().cast());
llvm::LLVMSetSection(section_var, section_name.as_ptr().cast());
llvm::LLVMSetInitializer(section_var, cx.const_bytes(section_contents));
llvm::LLVMSetGlobalConstant(section_var, llvm::True);
llvm::LLVMSetUnnamedAddress(section_var, llvm::UnnamedAddr::Global);

9
compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs
View File

@ -20,6 +20,7 @@
};
use crate::value::Value;
use cstr::cstr;
use rustc_codegen_ssa::debuginfo::type_names::cpp_like_debuginfo;
use rustc_codegen_ssa::debuginfo::type_names::VTableNameKind;
use rustc_codegen_ssa::traits::*;
@ -811,6 +812,7 @@ pub fn build_compile_unit_di_node<'ll, 'tcx>(
let name_in_debuginfo = name_in_debuginfo.to_string_lossy();
let work_dir = tcx.sess.opts.working_dir.to_string_lossy(FileNameDisplayPreference::Remapped);
let flags = "\0";
let output_filenames = tcx.output_filenames(());
let split_name = if tcx.sess.target_can_use_split_dwarf() {
output_filenames
@ -847,7 +849,7 @@ pub fn build_compile_unit_di_node<'ll, 'tcx>(
producer.as_ptr().cast(),
producer.len(),
tcx.sess.opts.optimize != config::OptLevel::No,
c"".as_ptr().cast(),
flags.as_ptr().cast(),
0,
// NB: this doesn't actually have any perceptible effect, it seems. LLVM will instead
// put the path supplied to `MCSplitDwarfFile` into the debug info of the final
@ -876,7 +878,8 @@ pub fn build_compile_unit_di_node<'ll, 'tcx>(
);
let val = llvm::LLVMMetadataAsValue(debug_context.llcontext, gcov_metadata);
llvm::LLVMAddNamedMetadataOperand(debug_context.llmod, c"llvm.gcov".as_ptr(), val);
let llvm_gcov_ident = cstr!("llvm.gcov");
llvm::LLVMAddNamedMetadataOperand(debug_context.llmod, llvm_gcov_ident.as_ptr(), val);
}
// Insert `llvm.ident` metadata on the wasm targets since that will
@ -889,7 +892,7 @@ pub fn build_compile_unit_di_node<'ll, 'tcx>(
);
llvm::LLVMAddNamedMetadataOperand(
debug_context.llmod,
c"llvm.ident".as_ptr(),
cstr!("llvm.ident").as_ptr(),
llvm::LLVMMDNodeInContext(debug_context.llcontext, &name_metadata, 1),
);
}

7
compiler/rustc_codegen_llvm/src/debuginfo/mod.rs
View File

@ -113,7 +113,7 @@ pub fn finalize(&self, sess: &Session) {
llvm::LLVMRustAddModuleFlag(
self.llmod,
llvm::LLVMModFlagBehavior::Warning,
c"Dwarf Version".as_ptr().cast(),
"Dwarf Version\0".as_ptr().cast(),
dwarf_version,
);
} else {
@ -121,16 +121,17 @@ pub fn finalize(&self, sess: &Session) {
llvm::LLVMRustAddModuleFlag(
self.llmod,
llvm::LLVMModFlagBehavior::Warning,
c"CodeView".as_ptr().cast(),
"CodeView\0".as_ptr().cast(),
1,
)
}
// Prevent bitcode readers from deleting the debug info.
let ptr = "Debug Info Version\0".as_ptr();
llvm::LLVMRustAddModuleFlag(
self.llmod,
llvm::LLVMModFlagBehavior::Warning,
c"Debug Info Version".as_ptr().cast(),
ptr.cast(),
llvm::LLVMRustDebugMetadataVersion(),
);
}

1
compiler/rustc_codegen_llvm/src/lib.rs
View File

@ -11,7 +11,6 @@
#![feature(let_chains)]
#![feature(never_type)]
#![feature(impl_trait_in_assoc_type)]
#![feature(c_str_literals)]
#![recursion_limit = "256"]
#![allow(rustc::potential_query_instability)]
#![deny(rustc::untranslatable_diagnostic)]

7
compiler/rustc_lexer/src/lib.rs
View File

@ -367,13 +367,6 @@ pub fn advance_token(&mut self) -> Token {
Some(|terminated| Byte { terminated }),
),
// c-string literal, raw c-string literal or identifier.
'c' => self.c_or_byte_string(
|terminated| CStr { terminated },
|n_hashes| RawCStr { n_hashes },
None,
),
// Identifier (this should be checked after other variant that can
// start as identifier).
c if is_id_start(c) => self.ident_or_unknown_prefix(),

1
library/std/src/lib.rs
View File

@ -241,7 +241,6 @@
#![feature(allocator_internals)]
#![feature(allow_internal_unsafe)]
#![feature(allow_internal_unstable)]
#![feature(c_str_literals)]
#![feature(c_unwind)]
#![feature(cfg_target_thread_local)]
#![feature(concat_idents)]

14
library/std/src/sys/unix/args.rs
View File

@ -242,15 +242,13 @@ pub fn args() -> Args {
let mut res = Vec::new();
unsafe {
let process_info_sel =
sel_registerName(c"processInfo".as_ptr() as *const libc::c_uchar);
let arguments_sel = sel_registerName(c"arguments".as_ptr() as *const libc::c_uchar);
let utf8_sel = sel_registerName(c"UTF8String".as_ptr() as *const libc::c_uchar);
let count_sel = sel_registerName(c"count".as_ptr() as *const libc::c_uchar);
let object_at_sel =
sel_registerName(c"objectAtIndex:".as_ptr() as *const libc::c_uchar);
let process_info_sel = sel_registerName("processInfo\0".as_ptr());
let arguments_sel = sel_registerName("arguments\0".as_ptr());
let utf8_sel = sel_registerName("UTF8String\0".as_ptr());
let count_sel = sel_registerName("count\0".as_ptr());
let object_at_sel = sel_registerName("objectAtIndex:\0".as_ptr());
let klass = objc_getClass(c"NSProcessInfo".as_ptr() as *const libc::c_uchar);
let klass = objc_getClass("NSProcessInfo\0".as_ptr());
let info = objc_msgSend(klass, process_info_sel);
let args = objc_msgSend(info, arguments_sel);

2
library/std/src/sys/unix/fs.rs
View File

@ -1097,7 +1097,7 @@ pub fn file_attr(&self) -> io::Result<FileAttr> {
cfg_has_statx! {
if let Some(ret) = unsafe { try_statx(
fd,
c"".as_ptr() as *const c_char,
b"\0" as *const _ as *const c_char,
libc::AT_EMPTY_PATH | libc::AT_STATX_SYNC_AS_STAT,
libc::STATX_ALL,
) } {

7
library/std/src/sys/unix/mod.rs
View File

@ -1,5 +1,6 @@
#![allow(missing_docs, nonstandard_style)]
use crate::ffi::CStr;
use crate::io::ErrorKind;
pub use self::rand::hashmap_random_keys;
@ -74,7 +75,7 @@ pub unsafe fn init(argc: isize, argv: *const *const u8, sigpipe: u8) {
// thread-id for the main thread and so renaming the main thread will rename the
// process and we only want to enable this on platforms we've tested.
if cfg!(target_os = "macos") {
thread::Thread::set_name(&c"main");
thread::Thread::set_name(&CStr::from_bytes_with_nul_unchecked(b"main\0"));
}
unsafe fn sanitize_standard_fds() {
@ -121,7 +122,7 @@ unsafe fn sanitize_standard_fds() {
if pfd.revents & libc::POLLNVAL == 0 {
continue;
}
if open64(c"/dev/null".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
if open64("/dev/null\0".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
// If the stream is closed but we failed to reopen it, abort the
// process. Otherwise we wouldn't preserve the safety of
// operations on the corresponding Rust object Stdin, Stdout, or
@ -151,7 +152,7 @@ unsafe fn sanitize_standard_fds() {
use libc::open64;
for fd in 0..3 {
if libc::fcntl(fd, libc::F_GETFD) == -1 && errno() == libc::EBADF {
if open64(c"/dev/null".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
if open64("/dev/null\0".as_ptr().cast(), libc::O_RDWR, 0) == -1 {
// If the stream is closed but we failed to reopen it, abort the
// process. Otherwise we wouldn't preserve the safety of
// operations on the corresponding Rust object Stdin, Stdout, or

9
library/std/src/sys/unix/process/process_common.rs
View File

@ -24,11 +24,11 @@
if #[cfg(target_os = "fuchsia")] {
// fuchsia doesn't have /dev/null
} else if #[cfg(target_os = "redox")] {
const DEV_NULL: &CStr = c"null:";
const DEV_NULL: &str = "null:\0";
} else if #[cfg(target_os = "vxworks")] {
const DEV_NULL: &CStr = c"/null";
const DEV_NULL: &str = "/null\0";
} else {
const DEV_NULL: &CStr = c"/dev/null";
const DEV_NULL: &str = "/dev/null\0";
}
}
@ -474,7 +474,8 @@ pub fn to_child_stdio(&self, readable: bool) -> io::Result<(ChildStdio, Option<A
let mut opts = OpenOptions::new();
opts.read(readable);
opts.write(!readable);
let fd = File::open_c(DEV_NULL, &opts)?;
let path = unsafe { CStr::from_ptr(DEV_NULL.as_ptr() as *const _) };
let fd = File::open_c(&path, &opts)?;
Ok((ChildStdio::Owned(fd.into_inner()), None))
}

3
library/std/src/sys/unix/thread.rs
View File

@ -163,9 +163,10 @@ pub fn set_name(name: &CStr) {
#[cfg(target_os = "netbsd")]
pub fn set_name(name: &CStr) {
unsafe {
let cname = CStr::from_bytes_with_nul_unchecked(b"%s\0".as_slice());
let res = libc::pthread_setname_np(
libc::pthread_self(),
c"%s".as_ptr(),
cname.as_ptr(),
name.as_ptr() as *mut libc::c_void,
);
debug_assert_eq!(res, 0);

4
library/std/src/sys/windows/c.rs
View File

@ -321,7 +321,7 @@ pub unsafe fn NtWriteFile(
// Functions that aren't available on every version of Windows that we support,
// but we still use them and just provide some form of a fallback implementation.
compat_fn_with_fallback! {
pub static KERNEL32: &CStr = c"kernel32";
pub static KERNEL32: &CStr = ansi_str!("kernel32");
// >= Win10 1607
// https://docs.microsoft.com/en-us/windows/win32/api/processthreadsapi/nf-processthreadsapi-setthreaddescription
@ -354,7 +354,7 @@ pub fn WaitOnAddress(
}
compat_fn_with_fallback! {
pub static NTDLL: &CStr = c"ntdll";
pub static NTDLL: &CStr = ansi_str!("ntdll");
pub fn NtCreateKeyedEvent(
KeyedEventHandle: LPHANDLE,

6
library/std/src/sys/windows/compat.rs
View File

@ -228,9 +228,9 @@ pub fn option() -> Option<F> {
/// Load all needed functions from "api-ms-win-core-synch-l1-2-0".
pub(super) fn load_synch_functions() {
fn try_load() -> Option<()> {
const MODULE_NAME: &CStr = c"api-ms-win-core-synch-l1-2-0";
const WAIT_ON_ADDRESS: &CStr = c"WaitOnAddress";
const WAKE_BY_ADDRESS_SINGLE: &CStr = c"WakeByAddressSingle";
const MODULE_NAME: &CStr = ansi_str!("api-ms-win-core-synch-l1-2-0");
const WAIT_ON_ADDRESS: &CStr = ansi_str!("WaitOnAddress");
const WAKE_BY_ADDRESS_SINGLE: &CStr = ansi_str!("WakeByAddressSingle");
// Try loading the library and all the required functions.
// If any step fails, then they all fail.

4
library/std/src/sys/windows/mod.rs
View File

@ -1,6 +1,6 @@
#![allow(missing_docs, nonstandard_style)]
use crate::ffi::{OsStr, OsString};
use crate::ffi::{CStr, OsStr, OsString};
use crate::io::ErrorKind;
use crate::mem::MaybeUninit;
use crate::os::windows::ffi::{OsStrExt, OsStringExt};
@ -51,7 +51,7 @@ pub unsafe fn init(_argc: isize, _argv: *const *const u8, _sigpipe: u8) {
// Normally, `thread::spawn` will call `Thread::set_name` but since this thread already
// exists, we have to call it ourselves.
thread::Thread::set_name(&c"main");
thread::Thread::set_name(&CStr::from_bytes_with_nul_unchecked(b"main\0"));
}
// SAFETY: must be called only once during runtime cleanup.

1
src/tools/tidy/src/deps.rs
View File

@ -131,6 +131,7 @@
"crossbeam-epoch",
"crossbeam-utils",
"crypto-common",
"cstr",
"datafrog",
"derive_more",
"digest",

4
tests/ui/rfcs/rfc-3348-c-string-literals/basic.rs
View File

@ -1,4 +1,6 @@
// run-pass
// FIXME(c_str_literals): This should be `run-pass`
// known-bug: #113333
// edition: 2021
#![feature(c_str_literals)]

25
tests/ui/rfcs/rfc-3348-c-string-literals/basic.stderr Normal file
View File

@ -0,0 +1,25 @@
error: prefix `c` is unknown
--> $DIR/basic.rs:8:27
|
LL | assert_eq!(b"test\0", c"test".to_bytes_with_nul());
| ^ unknown prefix
|
= note: prefixed identifiers and literals are reserved since Rust 2021
help: consider inserting whitespace here
|
LL | assert_eq!(b"test\0", c "test".to_bytes_with_nul());
| +
error: no rules expected the token `"test"`
--> $DIR/basic.rs:8:28
|
LL | assert_eq!(b"test\0", c"test".to_bytes_with_nul());
| -^^^^^
| |
| no rules expected this token in macro call
| help: missing comma here
|
= note: while trying to match sequence start
error: aborting due to 2 previous errors

24
tests/ui/rfcs/rfc-3348-c-string-literals/edition-2015-2018-lexing.rs Normal file
View File

@ -0,0 +1,24 @@
// Regression test for issue #113235.
// check-pass
// revisions: edition2015 edition2018
//[edition2015] edition: 2015
//[edition2018] edition: 2018
// Make sure that in pre-2021 editions we continue to parse the snippet
// `c"hello"` as an identifier followed by a (normal) string literal and
// allow the code below to compile.
// Prefixes including `c` as used by C string literals are only reserved
// in edition 2021 and onward.
//
// Consider checking out rust-2021/reserved-prefixes-migration.rs as well.
macro_rules! parse {
(c $e:expr) => {
$e
};
}
fn main() {
let _: &'static str = parse!(c"hello");
}

6
tests/ui/rfcs/rfc-3348-c-string-literals/gate.rs
View File

@ -1,4 +1,6 @@
// gate-test-c_str_literals
// known-bug: #113333
// edition: 2021
macro_rules! m {
($t:tt) => {}
@ -6,8 +8,8 @@ macro_rules! m {
fn main() {
c"foo";
//~^ ERROR: `c".."` literals are experimental
// FIXME(c_str_literals): This should be ``c".."` literals are experimental`
m!(c"test");
//~^ ERROR: `c".."` literals are experimental
// FIXME(c_str_literals): This should be ``c".."` literals are experimental`
}

35
tests/ui/rfcs/rfc-3348-c-string-literals/gate.stderr
View File

@ -1,21 +1,32 @@
error[E0658]: `c".."` literals are experimental
--> $DIR/gate.rs:8:5
error: prefix `c` is unknown
--> $DIR/gate.rs:10:5
|
LL | c"foo";
| ^^^^^^
| ^ unknown prefix
|
= note: see issue #105723 <https://github.com/rust-lang/rust/issues/105723> for more information
= help: add `#![feature(c_str_literals)]` to the crate attributes to enable
= note: prefixed identifiers and literals are reserved since Rust 2021
help: consider inserting whitespace here
|
LL | c "foo";
| +
error[E0658]: `c".."` literals are experimental
--> $DIR/gate.rs:11:8
error: prefix `c` is unknown
--> $DIR/gate.rs:13:8
|
LL | m!(c"test");
| ^^^^^^^
| ^ unknown prefix
|
= note: see issue #105723 <https://github.com/rust-lang/rust/issues/105723> for more information
= help: add `#![feature(c_str_literals)]` to the crate attributes to enable
= note: prefixed identifiers and literals are reserved since Rust 2021
help: consider inserting whitespace here
|
LL | m!(c "test");
| +
error: aborting due to 2 previous errors
error: expected one of `!`, `.`, `::`, `;`, `?`, `{`, `}`, or an operator, found `"foo"`
--> $DIR/gate.rs:10:6
|
LL | c"foo";
| ^^^^^ expected one of 8 possible tokens
error: aborting due to 3 previous errors
For more information about this error, try `rustc --explain E0658`.

BIN
tests/ui/rfcs/rfc-3348-c-string-literals/no-nuls.rs
View File

Binary file not shown.

BIN
tests/ui/rfcs/rfc-3348-c-string-literals/no-nuls.stderr
View File

Binary file not shown.

4
tests/ui/rfcs/rfc-3348-c-string-literals/non-ascii.rs
View File

@ -1,4 +1,6 @@
// run-pass
// FIXME(c_str_literals): This should be `run-pass`
// known-bug: #113333
// edition: 2021
#![feature(c_str_literals)]

38
tests/ui/rfcs/rfc-3348-c-string-literals/non-ascii.stderr Normal file
View File

@ -0,0 +1,38 @@
error: prefix `c` is unknown
--> $DIR/non-ascii.rs:9:9
|
LL | c"\xEF\x80🦀\u{1F980}".to_bytes_with_nul(),
| ^ unknown prefix
|
= note: prefixed identifiers and literals are reserved since Rust 2021
help: consider inserting whitespace here
|
LL | c "\xEF\x80🦀\u{1F980}".to_bytes_with_nul(),
| +
error: out of range hex escape
--> $DIR/non-ascii.rs:9:11
|
LL | c"\xEF\x80🦀\u{1F980}".to_bytes_with_nul(),
| ^^^^ must be a character in the range [\x00-\x7f]
error: out of range hex escape
--> $DIR/non-ascii.rs:9:15
|
LL | c"\xEF\x80🦀\u{1F980}".to_bytes_with_nul(),
| ^^^^ must be a character in the range [\x00-\x7f]
error: no rules expected the token `"\xEF\x80🦀\u{1F980}"`
--> $DIR/non-ascii.rs:9:10
|
LL | c"\xEF\x80🦀\u{1F980}".to_bytes_with_nul(),
| -^^^^^^^^^^^^^^^^^^^^
| |
| no rules expected this token in macro call
| help: missing comma here
|
note: while trying to match `,`
--> $SRC_DIR/core/src/macros/mod.rs:LL:COL
error: aborting due to 4 previous errors