Skip to content

Commit abd3637

Browse files
borsbors
committed
Auto merge of #105545 - erikdesjardins:ptrclean, r=bjorn3
cleanup: remove pointee types This can't be merged until the oldest LLVM version we support uses opaque pointers, which will be the case after #114148. (Also note `-Cllvm-args="-opaque-pointers=0"` can technically be used in LLVM 15, though I don't think we should support that configuration.) I initially hoped this would provide some minor perf win, but in #105412 (comment) it had very little impact, so this is only valuable as a cleanup. As a followup, this will enable #96242 to be resolved. r? `@ghost` `@rustbot` label S-blocked
2 parents fe90d7d + 5580012 commit abd3637

32 files changed

+227
-584
lines changed

‎compiler/rustc_codegen_gcc/src/builder.rs

-1
Original file line numberDiff line numberDiff line change
@@ -27,7 +27,6 @@ use rustc_codegen_ssa::traits::{
2727
BaseTypeMethods,
2828
BuilderMethods,
2929
ConstMethods,
30-
DerivedTypeMethods,
3130
LayoutTypeMethods,
3231
HasCodegen,
3332
OverflowOp,

‎compiler/rustc_codegen_gcc/src/common.rs

+4-4
Original file line numberDiff line numberDiff line change
@@ -16,6 +16,10 @@ use crate::context::CodegenCx;
1616
use crate::type_of::LayoutGccExt;
1717

1818
impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
19+
pub fn const_ptrcast(&self, val: RValue<'gcc>, ty: Type<'gcc>) -> RValue<'gcc> {
20+
self.context.new_cast(None, val, ty)
21+
}
22+
1923
pub fn const_bytes(&self, bytes: &[u8]) -> RValue<'gcc> {
2024
bytes_in_context(self, bytes)
2125
}
@@ -242,10 +246,6 @@ impl<'gcc, 'tcx> ConstMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
242246
const_alloc_to_gcc(self, alloc)
243247
}
244248

245-
fn const_ptrcast(&self, val: RValue<'gcc>, ty: Type<'gcc>) -> RValue<'gcc> {
246-
self.context.new_cast(None, val, ty)
247-
}
248-
249249
fn const_bitcast(&self, value: RValue<'gcc>, typ: Type<'gcc>) -> RValue<'gcc> {
250250
if value.get_type() == self.bool_type.make_pointer() {
251251
if let Some(pointee) = typ.get_pointee() {

‎compiler/rustc_codegen_gcc/src/intrinsic/mod.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -12,7 +12,7 @@ use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
1212
use rustc_codegen_ssa::mir::place::PlaceRef;
1313
use rustc_codegen_ssa::traits::{ArgAbiMethods, BaseTypeMethods, BuilderMethods, ConstMethods, IntrinsicCallMethods};
1414
#[cfg(feature="master")]
15-
use rustc_codegen_ssa::traits::{DerivedTypeMethods, MiscMethods};
15+
use rustc_codegen_ssa::traits::MiscMethods;
1616
use rustc_codegen_ssa::errors::InvalidMonomorphization;
1717
use rustc_middle::bug;
1818
use rustc_middle::ty::{self, Instance, Ty};

‎compiler/rustc_codegen_gcc/src/type_.rs

+21-5
Original file line numberDiff line numberDiff line change
@@ -54,6 +54,23 @@ impl<'gcc, 'tcx> CodegenCx<'gcc, 'tcx> {
5454
self.u128_type
5555
}
5656

57+
pub fn type_ptr_to(&self, ty: Type<'gcc>) -> Type<'gcc> {
58+
ty.make_pointer()
59+
}
60+
61+
pub fn type_ptr_to_ext(&self, ty: Type<'gcc>, _address_space: AddressSpace) -> Type<'gcc> {
62+
// TODO(antoyo): use address_space, perhaps with TYPE_ADDR_SPACE?
63+
ty.make_pointer()
64+
}
65+
66+
pub fn type_i8p(&self) -> Type<'gcc> {
67+
self.type_ptr_to(self.type_i8())
68+
}
69+
70+
pub fn type_i8p_ext(&self, address_space: AddressSpace) -> Type<'gcc> {
71+
self.type_ptr_to_ext(self.type_i8(), address_space)
72+
}
73+
5774
pub fn type_pointee_for_align(&self, align: Align) -> Type<'gcc> {
5875
// FIXME(eddyb) We could find a better approximation if ity.align < align.
5976
let ity = Integer::approximate_align(self, align);
@@ -149,13 +166,12 @@ impl<'gcc, 'tcx> BaseTypeMethods<'tcx> for CodegenCx<'gcc, 'tcx> {
149166
}
150167
}
151168

152-
fn type_ptr_to(&self, ty: Type<'gcc>) -> Type<'gcc> {
153-
ty.make_pointer()
169+
fn type_ptr(&self) -> Type<'gcc> {
170+
self.type_ptr_to(self.type_void())
154171
}
155172

156-
fn type_ptr_to_ext(&self, ty: Type<'gcc>, _address_space: AddressSpace) -> Type<'gcc> {
157-
// TODO(antoyo): use address_space, perhaps with TYPE_ADDR_SPACE?
158-
ty.make_pointer()
173+
fn type_ptr_ext(&self, address_space: AddressSpace) -> Type<'gcc> {
174+
self.type_ptr_to_ext(self.type_void(), address_space)
159175
}
160176

161177
fn element_type(&self, ty: Type<'gcc>) -> Type<'gcc> {

‎compiler/rustc_codegen_llvm/src/abi.rs

+4-13
Original file line numberDiff line numberDiff line change
@@ -216,9 +216,7 @@ impl<'ll, 'tcx> ArgAbiExt<'ll, 'tcx> for ArgAbi<'tcx, Ty<'tcx>> {
216216
// uses it for i16 -> {i8, i8}, but not for i24 -> {i8, i8, i8}.
217217
let can_store_through_cast_ptr = false;
218218
if can_store_through_cast_ptr {
219-
let cast_ptr_llty = bx.type_ptr_to(cast.llvm_type(bx));
220-
let cast_dst = bx.pointercast(dst.llval, cast_ptr_llty);
221-
bx.store(val, cast_dst, self.layout.align.abi);
219+
bx.store(val, dst.llval, self.layout.align.abi);
222220
} else {
223221
// The actual return type is a struct, but the ABI
224222
// adaptation code has cast it into some scalar type. The
@@ -336,7 +334,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
336334
PassMode::Direct(_) | PassMode::Pair(..) => self.ret.layout.immediate_llvm_type(cx),
337335
PassMode::Cast(cast, _) => cast.llvm_type(cx),
338336
PassMode::Indirect { .. } => {
339-
llargument_tys.push(cx.type_ptr_to(self.ret.memory_ty(cx)));
337+
llargument_tys.push(cx.type_ptr());
340338
cx.type_void()
341339
}
342340
};
@@ -364,9 +362,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
364362
}
365363
cast.llvm_type(cx)
366364
}
367-
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => {
368-
cx.type_ptr_to(arg.memory_ty(cx))
369-
}
365+
PassMode::Indirect { attrs: _, extra_attrs: None, on_stack: _ } => cx.type_ptr(),
370366
};
371367
llargument_tys.push(llarg_ty);
372368
}
@@ -379,12 +375,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
379375
}
380376

381377
fn ptr_to_llvm_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {
382-
unsafe {
383-
llvm::LLVMPointerType(
384-
self.llvm_type(cx),
385-
cx.data_layout().instruction_address_space.0 as c_uint,
386-
)
387-
}
378+
cx.type_ptr_ext(cx.data_layout().instruction_address_space)
388379
}
389380

390381
fn llvm_cconv(&self) -> llvm::CallConv {

‎compiler/rustc_codegen_llvm/src/allocator.rs

+1-1
Original file line numberDiff line numberDiff line change
@@ -28,7 +28,7 @@ pub(crate) unsafe fn codegen(
2828
tws => bug!("Unsupported target word size for int: {}", tws),
2929
};
3030
let i8 = llvm::LLVMInt8TypeInContext(llcx);
31-
let i8p = llvm::LLVMPointerType(i8, 0);
31+
let i8p = llvm::LLVMPointerTypeInContext(llcx, 0);
3232
let void = llvm::LLVMVoidTypeInContext(llcx);
3333

3434
if kind == AllocatorKind::Default {

‎compiler/rustc_codegen_llvm/src/back/write.rs

+3-4
Original file line numberDiff line numberDiff line change
@@ -4,7 +4,6 @@ use crate::back::profiling::{
44
};
55
use crate::base;
66
use crate::common;
7-
use crate::consts;
87
use crate::errors::{
98
CopyBitcode, FromLlvmDiag, FromLlvmOptimizationDiag, LlvmError, WithLlvmError, WriteBytecode,
109
};
@@ -992,7 +991,7 @@ fn create_msvc_imps(
992991
let prefix = if cgcx.target_arch == "x86" { "\x01__imp__" } else { "\x01__imp_" };
993992

994993
unsafe {
995-
let i8p_ty = Type::i8p_llcx(llcx);
994+
let ptr_ty = Type::ptr_llcx(llcx);
996995
let globals = base::iter_globals(llmod)
997996
.filter(|&val| {
998997
llvm::LLVMRustGetLinkage(val) == llvm::Linkage::ExternalLinkage
@@ -1012,8 +1011,8 @@ fn create_msvc_imps(
10121011
.collect::<Vec<_>>();
10131012

10141013
for (imp_name, val) in globals {
1015-
let imp = llvm::LLVMAddGlobal(llmod, i8p_ty, imp_name.as_ptr().cast());
1016-
llvm::LLVMSetInitializer(imp, consts::ptrcast(val, i8p_ty));
1014+
let imp = llvm::LLVMAddGlobal(llmod, ptr_ty, imp_name.as_ptr().cast());
1015+
llvm::LLVMSetInitializer(imp, val);
10171016
llvm::LLVMRustSetLinkage(imp, llvm::Linkage::ExternalLinkage);
10181017
}
10191018
}

‎compiler/rustc_codegen_llvm/src/base.rs

+1-2
Original file line numberDiff line numberDiff line change
@@ -123,8 +123,7 @@ pub fn compile_codegen_unit(tcx: TyCtxt<'_>, cgu_name: Symbol) -> (ModuleCodegen
123123
// happen after the llvm.used variables are created.
124124
for &(old_g, new_g) in cx.statics_to_rauw().borrow().iter() {
125125
unsafe {
126-
let bitcast = llvm::LLVMConstPointerCast(new_g, cx.val_ty(old_g));
127-
llvm::LLVMReplaceAllUsesWith(old_g, bitcast);
126+
llvm::LLVMReplaceAllUsesWith(old_g, new_g);
128127
llvm::LLVMDeleteGlobal(old_g);
129128
}
130129
}

‎compiler/rustc_codegen_llvm/src/builder.rs

+7-32
Original file line numberDiff line numberDiff line change
@@ -652,7 +652,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
652652
flags: MemFlags,
653653
) -> &'ll Value {
654654
debug!("Store {:?} -> {:?} ({:?})", val, ptr, flags);
655-
let ptr = self.check_store(val, ptr);
655+
assert_eq!(self.cx.type_kind(self.cx.val_ty(ptr)), TypeKind::Pointer);
656656
unsafe {
657657
let store = llvm::LLVMBuildStore(self.llbuilder, val, ptr);
658658
let align =
@@ -682,7 +682,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
682682
size: Size,
683683
) {
684684
debug!("Store {:?} -> {:?}", val, ptr);
685-
let ptr = self.check_store(val, ptr);
685+
assert_eq!(self.cx.type_kind(self.cx.val_ty(ptr)), TypeKind::Pointer);
686686
unsafe {
687687
let store = llvm::LLVMRustBuildAtomicStore(
688688
self.llbuilder,
@@ -873,8 +873,6 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
873873
assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memcpy not supported");
874874
let size = self.intcast(size, self.type_isize(), false);
875875
let is_volatile = flags.contains(MemFlags::VOLATILE);
876-
let dst = self.pointercast(dst, self.type_i8p());
877-
let src = self.pointercast(src, self.type_i8p());
878876
unsafe {
879877
llvm::LLVMRustBuildMemCpy(
880878
self.llbuilder,
@@ -900,8 +898,6 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
900898
assert!(!flags.contains(MemFlags::NONTEMPORAL), "non-temporal memmove not supported");
901899
let size = self.intcast(size, self.type_isize(), false);
902900
let is_volatile = flags.contains(MemFlags::VOLATILE);
903-
let dst = self.pointercast(dst, self.type_i8p());
904-
let src = self.pointercast(src, self.type_i8p());
905901
unsafe {
906902
llvm::LLVMRustBuildMemMove(
907903
self.llbuilder,
@@ -924,7 +920,6 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
924920
flags: MemFlags,
925921
) {
926922
let is_volatile = flags.contains(MemFlags::VOLATILE);
927-
let ptr = self.pointercast(ptr, self.type_i8p());
928923
unsafe {
929924
llvm::LLVMRustBuildMemSet(
930925
self.llbuilder,
@@ -981,7 +976,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
981976
}
982977

983978
fn cleanup_landing_pad(&mut self, pers_fn: &'ll Value) -> (&'ll Value, &'ll Value) {
984-
let ty = self.type_struct(&[self.type_i8p(), self.type_i32()], false);
979+
let ty = self.type_struct(&[self.type_ptr(), self.type_i32()], false);
985980
let landing_pad = self.landing_pad(ty, pers_fn, 0);
986981
unsafe {
987982
llvm::LLVMSetCleanup(landing_pad, llvm::True);
@@ -990,14 +985,14 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
990985
}
991986

992987
fn filter_landing_pad(&mut self, pers_fn: &'ll Value) -> (&'ll Value, &'ll Value) {
993-
let ty = self.type_struct(&[self.type_i8p(), self.type_i32()], false);
988+
let ty = self.type_struct(&[self.type_ptr(), self.type_i32()], false);
994989
let landing_pad = self.landing_pad(ty, pers_fn, 1);
995-
self.add_clause(landing_pad, self.const_array(self.type_i8p(), &[]));
990+
self.add_clause(landing_pad, self.const_array(self.type_ptr(), &[]));
996991
(self.extract_value(landing_pad, 0), self.extract_value(landing_pad, 1))
997992
}
998993

999994
fn resume(&mut self, exn0: &'ll Value, exn1: &'ll Value) {
1000-
let ty = self.type_struct(&[self.type_i8p(), self.type_i32()], false);
995+
let ty = self.type_struct(&[self.type_ptr(), self.type_i32()], false);
1001996
let mut exn = self.const_poison(ty);
1002997
exn = self.insert_value(exn, exn0, 0);
1003998
exn = self.insert_value(exn, exn1, 1);
@@ -1161,7 +1156,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
11611156

11621157
let llfn = unsafe { llvm::LLVMRustGetInstrProfIncrementIntrinsic(self.cx().llmod) };
11631158
let llty = self.cx.type_func(
1164-
&[self.cx.type_i8p(), self.cx.type_i64(), self.cx.type_i32(), self.cx.type_i32()],
1159+
&[self.cx.type_ptr(), self.cx.type_i64(), self.cx.type_i32(), self.cx.type_i32()],
11651160
self.cx.type_void(),
11661161
);
11671162
let args = &[fn_name, hash, num_counters, index];
@@ -1387,25 +1382,6 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
13871382
ret.expect("LLVM does not have support for catchret")
13881383
}
13891384

1390-
fn check_store(&mut self, val: &'ll Value, ptr: &'ll Value) -> &'ll Value {
1391-
let dest_ptr_ty = self.cx.val_ty(ptr);
1392-
let stored_ty = self.cx.val_ty(val);
1393-
let stored_ptr_ty = self.cx.type_ptr_to(stored_ty);
1394-
1395-
assert_eq!(self.cx.type_kind(dest_ptr_ty), TypeKind::Pointer);
1396-
1397-
if dest_ptr_ty == stored_ptr_ty {
1398-
ptr
1399-
} else {
1400-
debug!(
1401-
"type mismatch in store. \
1402-
Expected {:?}, got {:?}; inserting bitcast",
1403-
dest_ptr_ty, stored_ptr_ty
1404-
);
1405-
self.bitcast(ptr, stored_ptr_ty)
1406-
}
1407-
}
1408-
14091385
fn check_call<'b>(
14101386
&mut self,
14111387
typ: &str,
@@ -1466,7 +1442,6 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
14661442
return;
14671443
}
14681444

1469-
let ptr = self.pointercast(ptr, self.cx.type_i8p());
14701445
self.call_intrinsic(intrinsic, &[self.cx.const_u64(size), ptr]);
14711446
}
14721447

‎compiler/rustc_codegen_llvm/src/callee.rs

+1-35
Original file line numberDiff line numberDiff line change
@@ -4,13 +4,11 @@
44
//! and methods are represented as just a fn ptr and not a full
55
//! closure.
66
7-
use crate::abi::FnAbiLlvmExt;
87
use crate::attributes;
98
use crate::common;
109
use crate::context::CodegenCx;
1110
use crate::llvm;
1211
use crate::value::Value;
13-
use rustc_codegen_ssa::traits::*;
1412

1513
use rustc_middle::ty::layout::{FnAbiOf, HasTyCtxt};
1614
use rustc_middle::ty::{self, Instance, TypeVisitableExt};
@@ -45,39 +43,7 @@ pub fn get_fn<'ll, 'tcx>(cx: &CodegenCx<'ll, 'tcx>, instance: Instance<'tcx>) ->
4543
let fn_abi = cx.fn_abi_of_instance(instance, ty::List::empty());
4644

4745
let llfn = if let Some(llfn) = cx.get_declared_value(sym) {
48-
// Create a fn pointer with the new signature.
49-
let llptrty = fn_abi.ptr_to_llvm_type(cx);
50-
51-
// This is subtle and surprising, but sometimes we have to bitcast
52-
// the resulting fn pointer. The reason has to do with external
53-
// functions. If you have two crates that both bind the same C
54-
// library, they may not use precisely the same types: for
55-
// example, they will probably each declare their own structs,
56-
// which are distinct types from LLVM's point of view (nominal
57-
// types).
58-
//
59-
// Now, if those two crates are linked into an application, and
60-
// they contain inlined code, you can wind up with a situation
61-
// where both of those functions wind up being loaded into this
62-
// application simultaneously. In that case, the same function
63-
// (from LLVM's point of view) requires two types. But of course
64-
// LLVM won't allow one function to have two types.
65-
//
66-
// What we currently do, therefore, is declare the function with
67-
// one of the two types (whichever happens to come first) and then
68-
// bitcast as needed when the function is referenced to make sure
69-
// it has the type we expect.
70-
//
71-
// This can occur on either a crate-local or crate-external
72-
// reference. It also occurs when testing libcore and in some
73-
// other weird situations. Annoying.
74-
if cx.val_ty(llfn) != llptrty {
75-
debug!("get_fn: casting {:?} to {:?}", llfn, llptrty);
76-
cx.const_ptrcast(llfn, llptrty)
77-
} else {
78-
debug!("get_fn: not casting pointer!");
79-
llfn
80-
}
46+
llfn
8147
} else {
8248
let instance_def_id = instance.def_id();
8349
let llfn = if tcx.sess.target.arch == "x86" &&

0 commit comments

Comments
 (0)