CodeGen: rework Aggregate implemention for rvalue_creates_operand cases

[scottmcm]

A non-trivial refactor pulled out from #138759
r? workingjubilee

The previous implementation I'd written here based on index_by_increasing_offset is complicated to follow and difficult to extend to non-structs.

This changes the implementation, without actually changing any codegen (thus no test changes either), to be more like the existing extract_field (

rust/compiler/rustc_codegen_ssa/src/mir/operand.rs

Lines 345 to 425 in 2b0274c

	pub(crate) fn extract_field<Bx: BuilderMethods<'a, 'tcx, Value = V>>(
	&self,
	fx: &mut FunctionCx<'a, 'tcx, Bx>,
	bx: &mut Bx,
	i: usize,
	) -> Self {
	let field = self.layout.field(bx.cx(), i);
	let offset = self.layout.fields.offset(i);
	if !bx.is_backend_ref(self.layout) && bx.is_backend_ref(field) {
	if let BackendRepr::SimdVector { count, .. } = self.layout.backend_repr
	&& let BackendRepr::Memory { sized: true } = field.backend_repr
	&& count.is_power_of_two()
	{
	assert_eq!(field.size, self.layout.size);
	// This is being deprecated, but for now stdarch still needs it for
	// Newtype vector of array, e.g. #[repr(simd)] struct S([i32; 4]);
	let place = PlaceRef::alloca(bx, field);
	self.val.store(bx, place.val.with_type(self.layout));
	return bx.load_operand(place);
	} else {
	// Part of https://github.com/rust-lang/compiler-team/issues/838
	bug!("Non-ref type {self:?} cannot project to ref field type {field:?}");
	}
	}
	let val = if field.is_zst() {
	OperandValue::ZeroSized
	} else if field.size == self.layout.size {
	assert_eq!(offset.bytes(), 0);
	fx.codegen_transmute_operand(bx, *self, field).unwrap_or_else(|| {
	bug!(
	"Expected `codegen_transmute_operand` to handle equal-size \
	field {i:?} projection from {self:?} to {field:?}"
	)
	})
	} else {
	let (in_scalar, imm) = match (self.val, self.layout.backend_repr) {
	// Extract a scalar component from a pair.
	(OperandValue::Pair(a_llval, b_llval), BackendRepr::ScalarPair(a, b)) => {
	if offset.bytes() == 0 {
	assert_eq!(field.size, a.size(bx.cx()));
	(Some(a), a_llval)
	} else {
	assert_eq!(offset, a.size(bx.cx()).align_to(b.align(bx.cx()).abi));
	assert_eq!(field.size, b.size(bx.cx()));
	(Some(b), b_llval)
	}
	}
	_ => {
	span_bug!(fx.mir.span, "OperandRef::extract_field({:?}): not applicable", self)
	}
	};
	OperandValue::Immediate(match field.backend_repr {
	BackendRepr::SimdVector { .. } => imm,
	BackendRepr::Scalar(out_scalar) => {
	let Some(in_scalar) = in_scalar else {
	span_bug!(
	fx.mir.span,
	"OperandRef::extract_field({:?}): missing input scalar for output scalar",
	self
	)
	};
	if in_scalar != out_scalar {
	// If the backend and backend_immediate types might differ,
	// flip back to the backend type then to the new immediate.
	// This avoids nop truncations, but still handles things like
	// Bools in union fields needs to be truncated.
	let backend = bx.from_immediate(imm);
	bx.to_immediate_scalar(backend, out_scalar)
	} else {
	imm
	}
	}
	BackendRepr::ScalarPair(_, _) | BackendRepr::Memory { .. } => bug!(),
	})
	};
	OperandRef { val, layout: field }
	}

) in that it allows setting a particular field directly.

Notably I've found this one much easier to get right, in particular because having the OperandRef<Result<V, Scalar>> gives a really useful thing to include in ICE messages if something did happen to go wrong.

[rustbot]

These commits modify the Cargo.lock file. Unintentional changes to Cargo.lock can be introduced when switching branches and rebasing PRs.

If this was unintentional then you should revert the changes before this PR is merged.
Otherwise, you can ignore this comment.

Some changes occurred in compiler/rustc_codegen_ssa

cc @WaffleLapkin