Skip to content

Commit 2424c41

Browse files
committed
rustc: unpack scalar pair newtype layout ABIs.
1 parent fd4ed2b commit 2424c41

File tree

9 files changed

+185
-156
lines changed

9 files changed

+185
-156
lines changed

src/librustc/ty/layout.rs

Lines changed: 23 additions & 18 deletions
Original file line numberDiff line numberDiff line change
@@ -1076,10 +1076,11 @@ impl<'a, 'tcx> CachedLayout {
10761076
// We have exactly one non-ZST field.
10771077
match (non_zst_fields.next(), non_zst_fields.next()) {
10781078
(Some(field), None) => {
1079-
// Field size match and it has a scalar ABI.
1079+
// Field size matches and it has a scalar or scalar pair ABI.
10801080
if size == field.size {
10811081
match field.abi {
1082-
Abi::Scalar(_) => {
1082+
Abi::Scalar(_) |
1083+
Abi::ScalarPair(..) => {
10831084
abi = field.abi.clone();
10841085
}
10851086
_ => {}
@@ -2195,17 +2196,7 @@ impl<'a, 'tcx> TyLayout<'tcx> {
21952196
ty::TyAdt(def, substs) => {
21962197
match self.variants {
21972198
Variants::Single { index } => {
2198-
let mut field_ty = def.variants[index].fields[i].ty(tcx, substs);
2199-
2200-
// Treat NonZero<*T> as containing &T.
2201-
// This is especially useful for fat pointers.
2202-
if Some(def.did) == tcx.lang_items().non_zero() {
2203-
if let ty::TyRawPtr(mt) = field_ty.sty {
2204-
field_ty = tcx.mk_ref(tcx.types.re_erased, mt);
2205-
}
2206-
}
2207-
2208-
field_ty
2199+
def.variants[index].fields[i].ty(tcx, substs)
22092200
}
22102201

22112202
// Discriminant field for enums (where applicable).
@@ -2261,21 +2252,22 @@ impl<'a, 'tcx> TyLayout<'tcx> {
22612252
where C: LayoutOf<Ty<'tcx>, TyLayout = Result<Self, LayoutError<'tcx>>> +
22622253
HasTyCtxt<'tcx>
22632254
{
2264-
if let Abi::Scalar(Scalar { value, ref valid_range }) = self.abi {
2255+
let scalar_component = |scalar: &Scalar, offset| {
22652256
// FIXME(eddyb) support negative/wrap-around discriminant ranges.
2266-
return if valid_range.start < valid_range.end {
2257+
let Scalar { value, ref valid_range } = *scalar;
2258+
if valid_range.start < valid_range.end {
22672259
let bits = value.size(cx).bits();
22682260
assert!(bits <= 128);
22692261
let max_value = !0u128 >> (128 - bits);
22702262
if valid_range.start > 0 {
22712263
let niche = valid_range.start - 1;
2272-
Ok(Some((self.fields.offset(0), Scalar {
2264+
Ok(Some((offset, Scalar {
22732265
value,
22742266
valid_range: niche...valid_range.end
22752267
}, niche)))
22762268
} else if valid_range.end < max_value {
22772269
let niche = valid_range.end + 1;
2278-
Ok(Some((self.fields.offset(0), Scalar {
2270+
Ok(Some((offset, Scalar {
22792271
value,
22802272
valid_range: valid_range.start...niche
22812273
}, niche)))
@@ -2284,7 +2276,20 @@ impl<'a, 'tcx> TyLayout<'tcx> {
22842276
}
22852277
} else {
22862278
Ok(None)
2287-
};
2279+
}
2280+
};
2281+
2282+
match self.abi {
2283+
Abi::Scalar(ref scalar) => {
2284+
return scalar_component(scalar, Size::from_bytes(0));
2285+
}
2286+
Abi::ScalarPair(ref a, ref b) => {
2287+
if let Some(result) = scalar_component(a, Size::from_bytes(0))? {
2288+
return Ok(Some(result));
2289+
}
2290+
return scalar_component(b, a.value.size(cx).abi_align(b.value.align(cx)));
2291+
}
2292+
_ => {}
22882293
}
22892294

22902295
// Perhaps one of the fields is non-zero, let's recurse and find out.

src/librustc_trans/base.rs

Lines changed: 25 additions & 0 deletions
Original file line numberDiff line numberDiff line change
@@ -239,6 +239,31 @@ pub fn unsize_thin_ptr<'a, 'tcx>(
239239
let ptr_ty = bcx.ccx.layout_of(b).llvm_type(bcx.ccx).ptr_to();
240240
(bcx.pointercast(src, ptr_ty), unsized_info(bcx.ccx, a, b, None))
241241
}
242+
(&ty::TyAdt(def_a, _), &ty::TyAdt(def_b, _)) => {
243+
assert_eq!(def_a, def_b);
244+
245+
let src_layout = bcx.ccx.layout_of(src_ty);
246+
let dst_layout = bcx.ccx.layout_of(dst_ty);
247+
let mut result = None;
248+
for i in 0..src_layout.fields.count() {
249+
let src_f = src_layout.field(bcx.ccx, i);
250+
assert_eq!(src_layout.fields.offset(i).bytes(), 0);
251+
assert_eq!(dst_layout.fields.offset(i).bytes(), 0);
252+
if src_f.is_zst() {
253+
continue;
254+
}
255+
assert_eq!(src_layout.size, src_f.size);
256+
257+
let dst_f = dst_layout.field(bcx.ccx, i);
258+
assert_ne!(src_f.ty, dst_f.ty);
259+
assert_eq!(result, None);
260+
result = Some(unsize_thin_ptr(bcx, src, src_f.ty, dst_f.ty));
261+
}
262+
let (lldata, llextra) = result.unwrap();
263+
// HACK(eddyb) have to bitcast pointers until LLVM removes pointee types.
264+
(bcx.bitcast(lldata, dst_layout.scalar_pair_element_llvm_type(bcx.ccx, 0)),
265+
bcx.bitcast(llextra, dst_layout.scalar_pair_element_llvm_type(bcx.ccx, 1)))
266+
}
242267
_ => bug!("unsize_thin_ptr: called on bad types"),
243268
}
244269
}

src/librustc_trans/mir/block.rs

Lines changed: 10 additions & 37 deletions
Original file line numberDiff line numberDiff line change
@@ -670,46 +670,19 @@ impl<'a, 'tcx> MirContext<'a, 'tcx> {
670670
let tuple = self.trans_operand(bcx, operand);
671671

672672
// Handle both by-ref and immediate tuples.
673-
match tuple.val {
674-
Ref(llval, align) => {
675-
let tuple_ptr = LvalueRef::new_sized(llval, tuple.layout, align);
676-
for i in 0..tuple.layout.fields.count() {
677-
let field_ptr = tuple_ptr.project_field(bcx, i);
678-
self.trans_argument(bcx, field_ptr.load(bcx), llargs, &args[i]);
679-
}
680-
673+
if let Ref(llval, align) = tuple.val {
674+
let tuple_ptr = LvalueRef::new_sized(llval, tuple.layout, align);
675+
for i in 0..tuple.layout.fields.count() {
676+
let field_ptr = tuple_ptr.project_field(bcx, i);
677+
self.trans_argument(bcx, field_ptr.load(bcx), llargs, &args[i]);
681678
}
682-
Immediate(llval) => {
683-
for i in 0..tuple.layout.fields.count() {
684-
let field = tuple.layout.field(bcx.ccx, i);
685-
let elem = if field.is_zst() {
686-
C_undef(field.llvm_type(bcx.ccx))
687-
} else {
688-
// HACK(eddyb) have to bitcast pointers until LLVM removes pointee types.
689-
bcx.bitcast(llval, field.immediate_llvm_type(bcx.ccx))
690-
};
691-
// If the tuple is immediate, the elements are as well
692-
let op = OperandRef {
693-
val: Immediate(elem),
694-
layout: field,
695-
};
696-
self.trans_argument(bcx, op, llargs, &args[i]);
697-
}
698-
}
699-
Pair(a, b) => {
700-
let elems = [a, b];
701-
assert_eq!(tuple.layout.fields.count(), 2);
702-
for i in 0..2 {
703-
// Pair is always made up of immediates
704-
let op = OperandRef {
705-
val: Immediate(elems[i]),
706-
layout: tuple.layout.field(bcx.ccx, i),
707-
};
708-
self.trans_argument(bcx, op, llargs, &args[i]);
709-
}
679+
} else {
680+
// If the tuple is immediate, the elements are as well.
681+
for i in 0..tuple.layout.fields.count() {
682+
let op = tuple.extract_field(bcx, i);
683+
self.trans_argument(bcx, op, llargs, &args[i]);
710684
}
711685
}
712-
713686
}
714687

715688
fn get_personality_slot(&mut self, bcx: &Builder<'a, 'tcx>) -> LvalueRef<'tcx> {

src/librustc_trans/mir/constant.rs

Lines changed: 9 additions & 4 deletions
Original file line numberDiff line numberDiff line change
@@ -126,8 +126,12 @@ impl<'a, 'tcx> Const<'tcx> {
126126
layout::Abi::ScalarPair(ref a, ref b) => {
127127
let offset = layout.fields.offset(i);
128128
if offset.bytes() == 0 {
129-
assert_eq!(field.size, a.value.size(ccx));
130-
const_get_elt(self.llval, 0)
129+
if field.size == layout.size {
130+
self.llval
131+
} else {
132+
assert_eq!(field.size, a.value.size(ccx));
133+
const_get_elt(self.llval, 0)
134+
}
131135
} else {
132136
assert_eq!(offset, a.value.size(ccx)
133137
.abi_align(b.value.align(ccx)));
@@ -165,8 +169,9 @@ impl<'a, 'tcx> Const<'tcx> {
165169
let llvalty = val_ty(self.llval);
166170

167171
let val = if llty == llvalty && layout.is_llvm_scalar_pair() {
168-
let (a, b) = self.get_pair(ccx);
169-
OperandValue::Pair(a, b)
172+
OperandValue::Pair(
173+
const_get_elt(self.llval, 0),
174+
const_get_elt(self.llval, 1))
170175
} else if llty == llvalty && layout.is_llvm_immediate() {
171176
// If the types match, we can use the value directly.
172177
OperandValue::Immediate(self.llval)

src/librustc_trans/mir/lvalue.rs

Lines changed: 41 additions & 28 deletions
Original file line numberDiff line numberDiff line change
@@ -135,6 +135,31 @@ impl<'a, 'tcx> LvalueRef<'tcx> {
135135
return OperandRef::new_zst(bcx.ccx, self.layout);
136136
}
137137

138+
let scalar_load_metadata = |load, scalar: &layout::Scalar| {
139+
let (min, max) = (scalar.valid_range.start, scalar.valid_range.end);
140+
let max_next = max.wrapping_add(1);
141+
let bits = scalar.value.size(bcx.ccx).bits();
142+
assert!(bits <= 128);
143+
let mask = !0u128 >> (128 - bits);
144+
// For a (max) value of -1, max will be `-1 as usize`, which overflows.
145+
// However, that is fine here (it would still represent the full range),
146+
// i.e., if the range is everything. The lo==hi case would be
147+
// rejected by the LLVM verifier (it would mean either an
148+
// empty set, which is impossible, or the entire range of the
149+
// type, which is pointless).
150+
match scalar.value {
151+
layout::Int(..) if max_next & mask != min & mask => {
152+
// llvm::ConstantRange can deal with ranges that wrap around,
153+
// so an overflow on (max + 1) is fine.
154+
bcx.range_metadata(load, min..max_next);
155+
}
156+
layout::Pointer if 0 < min && min < max => {
157+
bcx.nonnull_metadata(load);
158+
}
159+
_ => {}
160+
}
161+
};
162+
138163
let val = if self.layout.is_llvm_immediate() {
139164
let mut const_llval = ptr::null_mut();
140165
unsafe {
@@ -149,39 +174,27 @@ impl<'a, 'tcx> LvalueRef<'tcx> {
149174
} else {
150175
let load = bcx.load(self.llval, self.alignment.non_abi());
151176
if let layout::Abi::Scalar(ref scalar) = self.layout.abi {
152-
let (min, max) = (scalar.valid_range.start, scalar.valid_range.end);
153-
let max_next = max.wrapping_add(1);
154-
let bits = scalar.value.size(bcx.ccx).bits();
155-
assert!(bits <= 128);
156-
let mask = !0u128 >> (128 - bits);
157-
// For a (max) value of -1, max will be `-1 as usize`, which overflows.
158-
// However, that is fine here (it would still represent the full range),
159-
// i.e., if the range is everything. The lo==hi case would be
160-
// rejected by the LLVM verifier (it would mean either an
161-
// empty set, which is impossible, or the entire range of the
162-
// type, which is pointless).
163-
match scalar.value {
164-
layout::Int(..) if max_next & mask != min & mask => {
165-
// llvm::ConstantRange can deal with ranges that wrap around,
166-
// so an overflow on (max + 1) is fine.
167-
bcx.range_metadata(load, min..max_next);
168-
}
169-
layout::Pointer if 0 < min && min < max => {
170-
bcx.nonnull_metadata(load);
171-
}
172-
_ => {}
173-
}
177+
scalar_load_metadata(load, scalar);
174178
}
175179
load
176180
};
177181
OperandValue::Immediate(base::to_immediate(bcx, llval, self.layout))
178-
} else if self.layout.is_llvm_scalar_pair() {
179-
let load = |i| {
180-
let x = self.project_field(bcx, i).load(bcx).immediate();
181-
// HACK(eddyb) have to bitcast pointers until LLVM removes pointee types.
182-
bcx.bitcast(x, self.layout.scalar_pair_element_llvm_type(bcx.ccx, i))
182+
} else if let layout::Abi::ScalarPair(ref a, ref b) = self.layout.abi {
183+
let load = |i, scalar: &layout::Scalar| {
184+
let mut llptr = bcx.struct_gep(self.llval, i as u64);
185+
// Make sure to always load i1 as i8.
186+
if scalar.is_bool() {
187+
llptr = bcx.pointercast(llptr, Type::i8p(bcx.ccx));
188+
}
189+
let load = bcx.load(llptr, self.alignment.non_abi());
190+
scalar_load_metadata(load, scalar);
191+
if scalar.is_bool() {
192+
bcx.trunc(load, Type::i1(bcx.ccx))
193+
} else {
194+
load
195+
}
183196
};
184-
OperandValue::Pair(load(0), load(1))
197+
OperandValue::Pair(load(0, a), load(1, b))
185198
} else {
186199
OperandValue::Ref(self.llval, self.alignment)
187200
};

0 commit comments

Comments
 (0)