Various rustc_codegen_ssa cleanups

compiler/rustc_codegen_gcc/src/common.rs

@@ -28,6 +28,19 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
  global
  // TODO(antoyo): set linkage.
  }
+
+ pub fn const_bitcast(&self, value: RValue<'gcc>, typ: Type<'gcc>) -> RValue<'gcc> {
+ if value.get_type() == self.bool_type.make_pointer() {
+ if let Some(pointee) = typ.get_pointee() {
+ if pointee.dyncast_vector().is_some() {
+ panic!()
+ }
+ }
+ }
+ // NOTE: since bitcast makes a value non-constant, don't bitcast if not necessary as some
+ // SIMD builtins require a constant value.
+ self.bitcast_if_needed(value, typ)
+ }
 }
 
 pub fn bytes_in_context<'gcc, 'tcx>(cx: &CodegenCx<'gcc, 'tcx>, bytes: &[u8]) -> RValue<'gcc> {
@@ -239,19 +252,6 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  const_alloc_to_gcc(self, alloc)
  }
 
- fn const_bitcast(&self, value: RValue<'gcc>, typ: Type<'gcc>) -> RValue<'gcc> {
- if value.get_type() == self.bool_type.make_pointer() {
- if let Some(pointee) = typ.get_pointee() {
- if pointee.dyncast_vector().is_some() {
- panic!()
- }
- }
- }
- // NOTE: since bitcast makes a value non-constant, don't bitcast if not necessary as some
- // SIMD builtins require a constant value.
- self.bitcast_if_needed(value, typ)
- }
-
  fn const_ptr_byte_offset(&self, base_addr: Self::Value, offset: abi::Size) -> Self::Value {
  self.context
  .new_array_access(None, base_addr, self.const_usize(offset.bytes()))

compiler/rustc_codegen_gcc/src/context.rs

@@ -27,7 +27,6 @@ use crate::callee::get_fn;
 use crate::common::SignType;
 
 pub struct CodegenCx<'gcc, 'tcx> {
- pub check_overflow: bool,
  pub codegen_unit: &'tcx CodegenUnit<'tcx>,
  pub context: &'gcc Context<'gcc>,
 
@@ -134,8 +133,6 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
  tcx: TyCtxt<'tcx>,
  supports_128bit_integers: bool,
  ) -> Self {
- let check_overflow = tcx.sess.overflow_checks();
-
  let create_type = |ctype, rust_type| {
  let layout = tcx.layout_of(ParamEnv::reveal_all().and(rust_type)).unwrap();
  let align = layout.align.abi.bytes();
@@ -271,7 +268,6 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
  }
 
  let mut cx = Self {
- check_overflow,
  codegen_unit,
  context,
  current_func: RefCell::new(None),
@@ -511,10 +507,6 @@ impl<'gcc, 'tcx> MiscMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  &self.tcx.sess
  }
 
- fn check_overflow(&self) -> bool {
- self.check_overflow
- }
-
  fn codegen_unit(&self) -> &'tcx CodegenUnit<'tcx> {
  self.codegen_unit
  }

compiler/rustc_codegen_gcc/src/type_.rs

@@ -89,13 +89,34 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
  ty::FloatTy::F128 => self.type_f128(),
  }
  }
-}
 
-impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
- fn type_i1(&self) -> Type<'gcc> {
+ pub fn type_i1(&self) -> Type<'gcc> {
  self.bool_type
  }
 
+ pub fn type_struct(&self, fields: &[Type<'gcc>], packed: bool) -> Type<'gcc> {
+ let types = fields.to_vec();
+ if let Some(typ) = self.struct_types.borrow().get(fields) {
+ return *typ;
+ }
+ let fields: Vec<_> = fields
+ .iter()
+ .enumerate()
+ .map(|(index, field)| {
+ self.context.new_field(None, *field, format!("field{}_TODO", index))
+ })
+ .collect();
+ let typ = self.context.new_struct_type(None, "struct", &fields).as_type();
+ if packed {
+ #[cfg(feature = "master")]
+ typ.set_packed();
+ }
+ self.struct_types.borrow_mut().insert(types, typ);
+ typ
+ }
+}
+
+impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  fn type_i8(&self) -> Type<'gcc> {
  self.i8_type
  }
@@ -131,7 +152,7 @@ impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  fn type_f64(&self) -> Type<'gcc> {
  self.double_type
  }
- 
+
  fn type_f128(&self) -> Type<'gcc> {
  unimplemented!("f16_f128")
  }
@@ -140,27 +161,6 @@ impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
  self.context.new_function_pointer_type(None, return_type, params, false)
  }
 
- fn type_struct(&self, fields: &[Type<'gcc>], packed: bool) -> Type<'gcc> {
- let types = fields.to_vec();
- if let Some(typ) = self.struct_types.borrow().get(fields) {
- return *typ;
- }
- let fields: Vec<_> = fields
- .iter()
- .enumerate()
- .map(|(index, field)| {
- self.context.new_field(None, *field, format!("field{}_TODO", index))
- })
- .collect();
- let typ = self.context.new_struct_type(None, "struct", &fields).as_type();
- if packed {
- #[cfg(feature = "master")]
- typ.set_packed();
- }
- self.struct_types.borrow_mut().insert(types, typ);
- typ
- }
-
  fn type_kind(&self, typ: Type<'gcc>) -> TypeKind {
  if self.is_int_type_or_bool(typ) {
  TypeKind::Integer

compiler/rustc_codegen_llvm/src/common.rs

@@ -329,10 +329,6 @@ impl<'ll, 'tcx> ConstMethods<'tcx> for CodegenCx<'ll, 'tcx> {
  const_alloc_to_llvm(self, alloc, /*static*/ false)
  }
 
- fn const_bitcast(&self, val: &'ll Value, ty: &'ll Type) -> &'ll Value {
- self.const_bitcast(val, ty)
- }
-
  fn const_ptr_byte_offset(&self, base_addr: Self::Value, offset: abi::Size) -> Self::Value {
  unsafe {
  llvm::LLVMConstInBoundsGEP2(

compiler/rustc_codegen_llvm/src/context.rs

@@ -3,6 +3,7 @@ use crate::back::write::to_llvm_code_model;
 use crate::callee::get_fn;
 use crate::coverageinfo;
 use crate::debuginfo;
+use crate::debuginfo::metadata::apply_vcall_visibility_metadata;
 use crate::llvm;
 use crate::llvm_util;
 use crate::type_::Type;
@@ -43,7 +44,6 @@ use std::str;
 /// All other LLVM data structures in the `CodegenCx` are tied to that `llvm::Context`.
 pub struct CodegenCx<'ll, 'tcx> {
  pub tcx: TyCtxt<'tcx>,
- pub check_overflow: bool,
  pub use_dll_storage_attrs: bool,
  pub tls_model: llvm::ThreadLocalMode,
 
@@ -441,8 +441,6 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
  // start) and then strongly recommending static linkage on Windows!
  let use_dll_storage_attrs = tcx.sess.target.is_like_windows;
 
- let check_overflow = tcx.sess.overflow_checks();
-
  let tls_model = to_llvm_tls_model(tcx.sess.tls_model());
 
  let (llcx, llmod) = (&*llvm_module.llcx, llvm_module.llmod());
@@ -466,7 +464,6 @@ impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
 
  CodegenCx {
  tcx,
- check_overflow,
  use_dll_storage_attrs,
  tls_model,
  llmod,
@@ -522,6 +519,15 @@ impl<'ll, 'tcx> MiscMethods<'tcx> for CodegenCx<'ll, 'tcx> {
  &self.vtables
  }
 
+ fn apply_vcall_visibility_metadata(
+ &self,
+ ty: Ty<'tcx>,
+ poly_trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
+ vtable: &'ll Value,
+ ) {
+ apply_vcall_visibility_metadata(self, ty, poly_trait_ref, vtable);
+ }
+
  fn get_fn(&self, instance: Instance<'tcx>) -> &'ll Value {
  get_fn(self, instance)
  }
@@ -596,10 +602,6 @@ impl<'ll, 'tcx> MiscMethods<'tcx> for CodegenCx<'ll, 'tcx> {
  self.tcx.sess
  }
 
- fn check_overflow(&self) -> bool {
- self.check_overflow
- }
-
  fn codegen_unit(&self) -> &'tcx CodegenUnit<'tcx> {
  self.codegen_unit
  }

compiler/rustc_codegen_llvm/src/debuginfo/metadata.rs

@@ -1449,12 +1449,18 @@ fn build_vtable_type_di_node<'ll, 'tcx>(
  .di_node
 }
 
-fn vcall_visibility_metadata<'ll, 'tcx>(
+pub(crate) fn apply_vcall_visibility_metadata<'ll, 'tcx>(
  cx: &CodegenCx<'ll, 'tcx>,
  ty: Ty<'tcx>,
  trait_ref: Option<PolyExistentialTraitRef<'tcx>>,
  vtable: &'ll Value,
 ) {
+ // FIXME(flip1995): The virtual function elimination optimization only works with full LTO in
+ // LLVM at the moment.
+ if !cx.sess().opts.unstable_opts.virtual_function_elimination || cx.sess().lto() != Lto::Fat {
+ return;
+ }
+
  enum VCallVisibility {
  Public = 0,
  LinkageUnit = 1,
@@ -1531,12 +1537,6 @@ pub fn create_vtable_di_node<'ll, 'tcx>(
  poly_trait_ref: Option<ty::PolyExistentialTraitRef<'tcx>>,
  vtable: &'ll Value,
 ) {
- // FIXME(flip1995): The virtual function elimination optimization only works with full LTO in
- // LLVM at the moment.
- if cx.sess().opts.unstable_opts.virtual_function_elimination && cx.sess().lto() == Lto::Fat {
- vcall_visibility_metadata(cx, ty, poly_trait_ref, vtable);
- }
-
  if cx.dbg_cx.is_none() {
  return;
  }

compiler/rustc_codegen_llvm/src/lib.rs

@@ -274,10 +274,11 @@ impl CodegenBackend for LlvmCodegenBackend {
  |tcx, ()| llvm_util::global_llvm_features(tcx.sess, true)
  }
 
- fn print(&self, req: &PrintRequest, out: &mut dyn PrintBackendInfo, sess: &Session) {
+ fn print(&self, req: &PrintRequest, out: &mut String, sess: &Session) {
+ use std::fmt::Write;
  match req.kind {
  PrintKind::RelocationModels => {
- writeln!(out, "Available relocation models:");
+ writeln!(out, "Available relocation models:").unwrap();
  for name in &[
  "static",
  "pic",
@@ -288,25 +289,25 @@ impl CodegenBackend for LlvmCodegenBackend {
  "ropi-rwpi",
  "default",
  ] {
- writeln!(out, " {name}");
+ writeln!(out, " {name}").unwrap();
  }
- writeln!(out);
+ writeln!(out).unwrap();
  }
  PrintKind::CodeModels => {
- writeln!(out, "Available code models:");
+ writeln!(out, "Available code models:").unwrap();
  for name in &["tiny", "small", "kernel", "medium", "large"] {
- writeln!(out, " {name}");
+ writeln!(out, " {name}").unwrap();
  }
- writeln!(out);
+ writeln!(out).unwrap();
  }
  PrintKind::TlsModels => {
- writeln!(out, "Available TLS models:");
+ writeln!(out, "Available TLS models:").unwrap();
  for name in
  &["global-dynamic", "local-dynamic", "initial-exec", "local-exec", "emulated"]
  {
- writeln!(out, " {name}");
+ writeln!(out, " {name}").unwrap();
  }
- writeln!(out);
+ writeln!(out).unwrap();
  }
  PrintKind::StackProtectorStrategies => {
  writeln!(
@@ -332,7 +333,8 @@ impl CodegenBackend for LlvmCodegenBackend {
  none
  Do not generate stack canaries.
 "#
- );
+ )
+ .unwrap();
  }
  _other => llvm_util::print(req, out, sess),
  }

compiler/rustc_codegen_llvm/src/llvm_util.rs

@@ -6,7 +6,6 @@ use crate::errors::{
 use crate::llvm;
 use libc::c_int;
 use rustc_codegen_ssa::base::wants_wasm_eh;
-use rustc_codegen_ssa::traits::PrintBackendInfo;
 use rustc_data_structures::fx::{FxHashMap, FxHashSet};
 use rustc_data_structures::small_c_str::SmallCStr;
 use rustc_fs_util::path_to_c_string;
@@ -18,6 +17,7 @@ use rustc_target::spec::{MergeFunctions, PanicStrategy};
 use rustc_target::target_features::RUSTC_SPECIFIC_FEATURES;
 
 use std::ffi::{c_char, c_void, CStr, CString};
+use std::fmt::Write;
 use std::path::Path;
 use std::ptr;
 use std::slice;
@@ -372,7 +372,7 @@ fn llvm_target_features(tm: &llvm::TargetMachine) -> Vec<(&str, &str)> {
  ret
 }
 
-fn print_target_features(out: &mut dyn PrintBackendInfo, sess: &Session, tm: &llvm::TargetMachine) {
+fn print_target_features(out: &mut String, sess: &Session, tm: &llvm::TargetMachine) {
  let mut llvm_target_features = llvm_target_features(tm);
  let mut known_llvm_target_features = FxHashSet::<&'static str>::default();
  let mut rustc_target_features = sess
@@ -412,24 +412,26 @@ fn print_target_features(out: &mut dyn PrintBackendInfo, sess: &Session, tm: &ll
  .max()
  .unwrap_or(0);
 
- writeln!(out, "Features supported by rustc for this target:");
+ writeln!(out, "Features supported by rustc for this target:").unwrap();
  for (feature, desc) in &rustc_target_features {
- writeln!(out, " {feature:max_feature_len$} - {desc}.");
+ writeln!(out, " {feature:max_feature_len$} - {desc}.").unwrap();
  }
- writeln!(out, "\nCode-generation features supported by LLVM for this target:");
+ writeln!(out, "\nCode-generation features supported by LLVM for this target:").unwrap();
  for (feature, desc) in &llvm_target_features {
- writeln!(out, " {feature:max_feature_len$} - {desc}.");
+ writeln!(out, " {feature:max_feature_len$} - {desc}.").unwrap();
  }
  if llvm_target_features.is_empty() {
- writeln!(out, " Target features listing is not supported by this LLVM version.");
+ writeln!(out, " Target features listing is not supported by this LLVM version.")
+ .unwrap();
  }
- writeln!(out, "\nUse +feature to enable a feature, or -feature to disable it.");
- writeln!(out, "For example, rustc -C target-cpu=mycpu -C target-feature=+feature1,-feature2\n");
- writeln!(out, "Code-generation features cannot be used in cfg or #[target_feature],");
- writeln!(out, "and may be renamed or removed in a future version of LLVM or rustc.\n");
+ writeln!(out, "\nUse +feature to enable a feature, or -feature to disable it.").unwrap();
+ writeln!(out, "For example, rustc -C target-cpu=mycpu -C target-feature=+feature1,-feature2\n")
+ .unwrap();
+ writeln!(out, "Code-generation features cannot be used in cfg or #[target_feature],").unwrap();
+ writeln!(out, "and may be renamed or removed in a future version of LLVM or rustc.\n").unwrap();
 }
 
-pub(crate) fn print(req: &PrintRequest, mut out: &mut dyn PrintBackendInfo, sess: &Session) {
+pub(crate) fn print(req: &PrintRequest, mut out: &mut String, sess: &Session) {
  require_inited();
  let tm = create_informational_target_machine(sess);
  match req.kind {
@@ -440,9 +442,9 @@ pub(crate) fn print(req: &PrintRequest, mut out: &mut dyn PrintBackendInfo, sess
  let cpu_cstring = CString::new(handle_native(sess.target.cpu.as_ref()))
  .unwrap_or_else(|e| bug!("failed to convert to cstring: {}", e));
  unsafe extern "C" fn callback(out: *mut c_void, string: *const c_char, len: usize) {
- let out = &mut *(out as *mut &mut dyn PrintBackendInfo);
+ let out = &mut *(out as *mut &mut String);
  let bytes = slice::from_raw_parts(string as *const u8, len);
- write!(out, "{}", String::from_utf8_lossy(bytes));
+ write!(out, "{}", String::from_utf8_lossy(bytes)).unwrap();
  }
  unsafe {
  llvm::LLVMRustPrintTargetCPUs(