Skip to content

Commit 458bc42

Browse files
sayantnsayantn
committed
Add auto-destructuring for structs
 - Remove redundant bitcasts at callsite
1 parent 64023da commit 458bc42

File tree

4 files changed

+141
-50
lines changed

4 files changed

+141
-50
lines changed

‎compiler/rustc_codegen_llvm/src/abi.rs

Lines changed: 29 additions & 2 deletions
Original file line numberDiff line numberDiff line change
@@ -7,6 +7,7 @@ use rustc_abi::{
77
X86Call,
88
};
99
use rustc_codegen_ssa::MemFlags;
10+
use rustc_codegen_ssa::common::TypeKind;
1011
use rustc_codegen_ssa::mir::operand::{OperandRef, OperandValue};
1112
use rustc_codegen_ssa::mir::place::{PlaceRef, PlaceValue};
1213
use rustc_codegen_ssa::traits::*;
@@ -22,7 +23,7 @@ use smallvec::SmallVec;
2223

2324
use crate::attributes::{self, llfn_attrs_from_instance};
2425
use crate::builder::Builder;
25-
use crate::context::CodegenCx;
26+
use crate::context::{CodegenCx, GenericCx, SCx};
2627
use crate::llvm::{self, Attribute, AttributePlace};
2728
use crate::type_::Type;
2829
use crate::type_of::LayoutLlvmExt;
@@ -353,6 +354,32 @@ pub(crate) trait FnAbiLlvmExt<'ll, 'tcx> {
353354
);
354355
}
355356

357+
impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
358+
pub(crate) fn equate_ty(&self, rust_ty: &'ll Type, llvm_ty: &'ll Type) -> bool {
359+
if rust_ty == llvm_ty {
360+
return true;
361+
}
362+
363+
match self.type_kind(llvm_ty) {
364+
TypeKind::Struct if self.type_kind(rust_ty) == TypeKind::Struct => {
365+
let rust_element_tys = self.struct_element_types(rust_ty);
366+
let llvm_element_tys = self.struct_element_types(llvm_ty);
367+
368+
if rust_element_tys.len() != llvm_element_tys.len() {
369+
return false;
370+
}
371+
372+
iter::zip(rust_element_tys, llvm_element_tys).all(
373+
|(rust_element_ty, llvm_element_ty)| {
374+
self.equate_ty(rust_element_ty, llvm_element_ty)
375+
},
376+
)
377+
}
378+
_ => false,
379+
}
380+
}
381+
}
382+
356383
impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
357384
fn llvm_return_type(&self, cx: &CodegenCx<'ll, 'tcx>) -> &'ll Type {
358385
match &self.ret.mode {
@@ -442,7 +469,7 @@ impl<'ll, 'tcx> FnAbiLlvmExt<'ll, 'tcx> for FnAbi<'tcx, Ty<'tcx>> {
442469
// todo: add bypasses for types not accessible from Rust here
443470
iter::once((rust_return_ty, llvm_return_ty))
444471
.chain(iter::zip(rust_argument_tys, llvm_argument_tys))
445-
.all(|(rust_ty, llvm_ty)| rust_ty == llvm_ty)
472+
.all(|(rust_ty, llvm_ty)| cx.equate_ty(rust_ty, llvm_ty))
446473
}
447474

448475
fn llvm_type(

‎compiler/rustc_codegen_llvm/src/builder.rs

Lines changed: 99 additions & 48 deletions
Original file line numberDiff line numberDiff line change
@@ -66,7 +66,6 @@ impl<'a, 'll> SBuilder<'a, 'll> {
6666
) -> &'ll Value {
6767
debug!("call {:?} with args ({:?})", llfn, args);
6868

69-
let args = self.check_call("call", llty, llfn, args);
7069
let funclet_bundle = funclet.map(|funclet| funclet.bundle());
7170
let mut bundles: SmallVec<[_; 2]> = SmallVec::new();
7271
if let Some(funclet_bundle) = funclet_bundle {
@@ -348,7 +347,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
348347
) -> &'ll Value {
349348
debug!("invoke {:?} with args ({:?})", llfn, args);
350349

351-
let args = self.check_call("invoke", llty, llfn, args);
350+
let args = self.cast_arguments("invoke", llty, llfn, args, fn_abi.is_some());
352351
let funclet_bundle = funclet.map(|funclet| funclet.bundle());
353352
let mut bundles: SmallVec<[_; 2]> = SmallVec::new();
354353
if let Some(funclet_bundle) = funclet_bundle {
@@ -380,8 +379,10 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
380379
};
381380
if let Some(fn_abi) = fn_abi {
382381
fn_abi.apply_attrs_callsite(self, invoke, llfn);
382+
self.cast_return(fn_abi, llfn, invoke)
383+
} else {
384+
invoke
383385
}
384-
invoke
385386
}
386387

387388
fn unreachable(&mut self) {
@@ -1343,7 +1344,7 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
13431344
) -> &'ll Value {
13441345
debug!("call {:?} with args ({:?})", llfn, args);
13451346

1346-
let args = self.check_call("call", llty, llfn, args);
1347+
let args = self.cast_arguments("call", llty, llfn, args, fn_abi.is_some());
13471348
let funclet_bundle = funclet.map(|funclet| funclet.bundle());
13481349
let mut bundles: SmallVec<[_; 2]> = SmallVec::new();
13491350
if let Some(funclet_bundle) = funclet_bundle {
@@ -1373,8 +1374,10 @@ impl<'a, 'll, 'tcx> BuilderMethods<'a, 'tcx> for Builder<'a, 'll, 'tcx> {
13731374
};
13741375
if let Some(fn_abi) = fn_abi {
13751376
fn_abi.apply_attrs_callsite(self, call, llfn);
1377+
self.cast_return(fn_abi, llfn, call)
1378+
} else {
1379+
call
13761380
}
1377-
call
13781381
}
13791382

13801383
fn zext(&mut self, val: &'ll Value, dest_ty: &'ll Type) -> &'ll Value {
@@ -1541,47 +1544,6 @@ impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
15411544
ret.expect("LLVM does not have support for catchret")
15421545
}
15431546

1544-
fn check_call<'b>(
1545-
&mut self,
1546-
typ: &str,
1547-
fn_ty: &'ll Type,
1548-
llfn: &'ll Value,
1549-
args: &'b [&'ll Value],
1550-
) -> Cow<'b, [&'ll Value]> {
1551-
assert!(
1552-
self.cx.type_kind(fn_ty) == TypeKind::Function,
1553-
"builder::{typ} not passed a function, but {fn_ty:?}"
1554-
);
1555-
1556-
let param_tys = self.cx.func_params_types(fn_ty);
1557-
1558-
let all_args_match = iter::zip(&param_tys, args.iter().map(|&v| self.cx.val_ty(v)))
1559-
.all(|(expected_ty, actual_ty)| *expected_ty == actual_ty);
1560-
1561-
if all_args_match {
1562-
return Cow::Borrowed(args);
1563-
}
1564-
1565-
let casted_args: Vec<_> = iter::zip(param_tys, args)
1566-
.enumerate()
1567-
.map(|(i, (expected_ty, &actual_val))| {
1568-
let actual_ty = self.cx.val_ty(actual_val);
1569-
if expected_ty != actual_ty {
1570-
debug!(
1571-
"type mismatch in function call of {:?}. \
1572-
Expected {:?} for param {}, got {:?}; injecting bitcast",
1573-
llfn, expected_ty, i, actual_ty
1574-
);
1575-
self.bitcast(actual_val, expected_ty)
1576-
} else {
1577-
actual_val
1578-
}
1579-
})
1580-
.collect();
1581-
1582-
Cow::Owned(casted_args)
1583-
}
1584-
15851547
pub(crate) fn va_arg(&mut self, list: &'ll Value, ty: &'ll Type) -> &'ll Value {
15861548
unsafe { llvm::LLVMBuildVAArg(self.llbuilder, list, ty, UNNAMED) }
15871549
}
@@ -1633,6 +1595,93 @@ impl<'a, 'll, CX: Borrow<SCx<'ll>>> GenericBuilder<'a, 'll, CX> {
16331595
}
16341596
}
16351597
impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
1598+
fn autocast(
1599+
&mut self,
1600+
llfn: &'ll Value,
1601+
val: &'ll Value,
1602+
src_ty: &'ll Type,
1603+
dest_ty: &'ll Type,
1604+
is_argument: bool,
1605+
) -> &'ll Value {
1606+
let (rust_ty, llvm_ty) = if is_argument { (src_ty, dest_ty) } else { (dest_ty, src_ty) };
1607+
1608+
if rust_ty == llvm_ty {
1609+
return val;
1610+
}
1611+
1612+
match self.type_kind(llvm_ty) {
1613+
TypeKind::Struct => {
1614+
let mut ret = self.const_poison(dest_ty);
1615+
for (idx, (src_element_ty, dest_element_ty)) in
1616+
iter::zip(self.struct_element_types(src_ty), self.struct_element_types(dest_ty))
1617+
.enumerate()
1618+
{
1619+
let elt = self.extract_value(val, idx as u64);
1620+
let casted_elt =
1621+
self.autocast(llfn, elt, src_element_ty, dest_element_ty, is_argument);
1622+
ret = self.insert_value(ret, casted_elt, idx as u64);
1623+
}
1624+
ret
1625+
}
1626+
_ => unreachable!(),
1627+
}
1628+
}
1629+
1630+
fn cast_arguments<'b>(
1631+
&mut self,
1632+
typ: &str,
1633+
fn_ty: &'ll Type,
1634+
llfn: &'ll Value,
1635+
args: &'b [&'ll Value],
1636+
has_fnabi: bool,
1637+
) -> Cow<'b, [&'ll Value]> {
1638+
assert_eq!(
1639+
self.type_kind(fn_ty),
1640+
TypeKind::Function,
1641+
"{typ} not passed a function, but {fn_ty:?}"
1642+
);
1643+
1644+
let param_tys = self.func_params_types(fn_ty);
1645+
1646+
let mut casted_args = Cow::Borrowed(args);
1647+
1648+
for (idx, (dest_ty, &arg)) in iter::zip(param_tys, args).enumerate() {
1649+
let src_ty = self.val_ty(arg);
1650+
assert!(
1651+
self.equate_ty(src_ty, dest_ty),
1652+
"Cannot match `{dest_ty:?}` (expected) with `{src_ty:?}` (found) in `{llfn:?}`"
1653+
);
1654+
1655+
let casted_arg = self.autocast(llfn, arg, src_ty, dest_ty, true);
1656+
if arg != casted_arg {
1657+
assert!(
1658+
has_fnabi,
1659+
"Should inject autocasts in function call of {llfn:?}, but not able to get Rust signature"
1660+
);
1661+
1662+
casted_args.to_mut()[idx] = casted_arg;
1663+
}
1664+
}
1665+
1666+
casted_args
1667+
}
1668+
1669+
fn cast_return(
1670+
&mut self,
1671+
fn_abi: &FnAbi<'tcx, Ty<'tcx>>,
1672+
llfn: &'ll Value,
1673+
ret: &'ll Value,
1674+
) -> &'ll Value {
1675+
let src_ty = self.val_ty(ret);
1676+
let dest_ty = fn_abi.llvm_return_type(self);
1677+
assert!(
1678+
self.equate_ty(dest_ty, src_ty),
1679+
"Cannot match `{src_ty:?}` (expected) with `{dest_ty:?}` (found) in `{llfn:?}`"
1680+
);
1681+
1682+
self.autocast(llfn, ret, src_ty, dest_ty, false)
1683+
}
1684+
16361685
pub(crate) fn landing_pad(
16371686
&mut self,
16381687
ty: &'ll Type,
@@ -1662,7 +1711,7 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
16621711
) -> &'ll Value {
16631712
debug!("invoke {:?} with args ({:?})", llfn, args);
16641713

1665-
let args = self.check_call("callbr", llty, llfn, args);
1714+
let args = self.cast_arguments("callbr", llty, llfn, args, fn_abi.is_some());
16661715
let funclet_bundle = funclet.map(|funclet| funclet.bundle());
16671716
let mut bundles: SmallVec<[_; 2]> = SmallVec::new();
16681717
if let Some(funclet_bundle) = funclet_bundle {
@@ -1695,8 +1744,10 @@ impl<'a, 'll, 'tcx> Builder<'a, 'll, 'tcx> {
16951744
};
16961745
if let Some(fn_abi) = fn_abi {
16971746
fn_abi.apply_attrs_callsite(self, callbr, llfn);
1747+
self.cast_return(fn_abi, llfn, callbr)
1748+
} else {
1749+
callbr
16981750
}
1699-
callbr
17001751
}
17011752

17021753
// Emits CFI pointer type membership tests.

‎compiler/rustc_codegen_llvm/src/llvm/ffi.rs

Lines changed: 3 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -1738,6 +1738,9 @@ unsafe extern "C" {
17381738
Packed: Bool,
17391739
);
17401740

1741+
pub(crate) fn LLVMCountStructElementTypes(StructTy: &Type) -> c_uint;
1742+
pub(crate) fn LLVMGetStructElementTypes<'a>(StructTy: &'a Type, Dest: *mut &'a Type);
1743+
17411744
pub(crate) safe fn LLVMMetadataAsValue<'a>(C: &'a Context, MD: &'a Metadata) -> &'a Value;
17421745

17431746
pub(crate) fn LLVMSetUnnamedAddress(Global: &Value, UnnamedAddr: UnnamedAddr);

‎compiler/rustc_codegen_llvm/src/type_.rs

Lines changed: 10 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -88,6 +88,16 @@ impl<'ll, CX: Borrow<SCx<'ll>>> GenericCx<'ll, CX> {
8888
pub(crate) fn func_is_variadic(&self, ty: &'ll Type) -> bool {
8989
unsafe { llvm::LLVMIsFunctionVarArg(ty) == True }
9090
}
91+
92+
pub(crate) fn struct_element_types(&self, ty: &'ll Type) -> Vec<&'ll Type> {
93+
unsafe {
94+
let n_args = llvm::LLVMCountStructElementTypes(ty) as usize;
95+
let mut args = Vec::with_capacity(n_args);
96+
llvm::LLVMGetStructElementTypes(ty, args.as_mut_ptr());
97+
args.set_len(n_args);
98+
args
99+
}
100+
}
91101
}
92102
impl<'ll, 'tcx> CodegenCx<'ll, 'tcx> {
93103
pub(crate) fn type_bool(&self) -> &'ll Type {

0 commit comments

Comments
 (0)