1use arrayvec::ArrayVec;
2use rustc_abi::{
3 Align, BackendRepr, FieldsShape, Float, HasDataLayout, Integer, Numeric, Primitive, Reg,
4 RegKind, Size, TyAbiInterface, TyAndLayout, Variants,
5};
6
7use crate::callconv::{ArgAbi, ArgAttribute, CastTarget, FnAbi, Uniform};
8use crate::spec::{HasTargetSpec, Os};
9
10#[derive(#[automatically_derived]impl ::core::marker::Copy for DoubleWord { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for DoubleWord {
}
#[automatically_derived]impl ::core::clone::Clone for DoubleWord {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self {
let _: ::core::clone::AssertParamIsClone<[Word; 2]>;
*self
}
}Clone)]
14enum DoubleWord {
15 F64,
16 F128Start,
17 F128End,
18 Words([Word; 2]),
19}
20
21#[derive(#[automatically_derived]impl ::core::marker::Copy for Word { }Copy, #[automatically_derived]#[doc(hidden)]unsafe impl ::core::clone::TrivialClone
for Word {
}
#[automatically_derived]impl ::core::clone::Clone for Word {
#[inline]
#[rustc_trivial_field_reads]
fn clone(&self) -> Self { *self }
}Clone)]
22enum Word {
23 F32,
24 Integer,
25}
26
27fn classify<'a, Ty, C>(
28 cx: &C,
29 arg_layout: &TyAndLayout<'a, Ty>,
30 offset: Size,
31 double_words: &mut [DoubleWord; 4],
32) where
33 Ty: TyAbiInterface<'a, C> + Copy,
34 C: HasDataLayout,
35{
36 match arg_layout.backend_repr {
40 BackendRepr::Scalar(scalar) => match scalar.primitive() {
41 Primitive::Float(float) => {
42 if offset.is_aligned(Ord::min(float.align(cx), Align::EIGHT)) {
43 let index = offset.bytes_usize() / 8;
44 match float {
45 Float::F128 => {
46 double_words[index] = DoubleWord::F128Start;
47 double_words[index + 1] = DoubleWord::F128End;
48 }
49 Float::F64 => {
50 double_words[index] = DoubleWord::F64;
51 }
52 Float::F32 => match &mut double_words[index] {
53 DoubleWord::Words(words) => {
54 words[(offset.bytes_usize() % 8) / 4] = Word::F32;
55 }
56 _ => ::core::panicking::unreachable_default_msg()unreachable!(),
57 },
58 Float::F16 => {
59 }
61 Float::F16B => {
::core::panicking::panic_fmt(format_args!("internal error: entered unreachable code: {0}",
format_args!("`f16b` unsupported on sparc64")));
}unreachable!("`f16b` unsupported on sparc64"),
62 Float::X87F80 => {
::core::panicking::panic_fmt(format_args!("internal error: entered unreachable code: {0}",
format_args!("`x87_f80` unsupported on sparc64")));
}unreachable!("`x87_f80` unsupported on sparc64"),
63 Float::PpcF128 => {
::core::panicking::panic_fmt(format_args!("internal error: entered unreachable code: {0}",
format_args!("`ppcf128` unsupported on sparc64")));
}unreachable!("`ppcf128` unsupported on sparc64"),
64 }
65 } else {
66 }
68 }
69 Primitive::Int(_, _) | Primitive::Pointer(_) => { }
70 },
71 BackendRepr::SimdVector { .. } => {}
72 BackendRepr::SimdScalableVector { .. } => {}
73 BackendRepr::ScalarPair { .. } | BackendRepr::Memory { .. } => match arg_layout.fields {
74 FieldsShape::Primitive => {
75 {
::core::panicking::panic_fmt(format_args!("internal error: entered unreachable code: {0}",
format_args!("aggregates can\'t have `FieldsShape::Primitive`")));
}unreachable!("aggregates can't have `FieldsShape::Primitive`")
76 }
77 FieldsShape::Union(_) => {
78 if !arg_layout.is_zst() {
79 if arg_layout.is_transparent() {
80 let non_1zst_elem = arg_layout.non_1zst_field(cx).expect("not exactly one non-1-ZST field in non-ZST repr(transparent) union").1;
81 classify(cx, &non_1zst_elem, offset, double_words);
82 }
83 }
84 }
85 FieldsShape::Array { .. } => {}
86 FieldsShape::Arbitrary { .. } => match arg_layout.variants {
87 Variants::Multiple { .. } => {}
88 Variants::Single { .. } | Variants::Empty => {
89 for i in arg_layout.fields.index_by_increasing_offset() {
93 classify(
94 cx,
95 &arg_layout.field(cx, i),
96 offset + arg_layout.fields.offset(i),
97 double_words,
98 );
99 }
100 }
101 },
102 },
103 }
104}
105
106fn classify_arg<'a, Ty, C>(
107 cx: &C,
108 arg: &mut ArgAbi<'a, Ty>,
109 in_registers_max: Size,
110 total_double_word_count: &mut usize,
111) where
112 Ty: TyAbiInterface<'a, C> + Copy,
113 C: HasDataLayout,
114{
115 let pad = !total_double_word_count.is_multiple_of(2) && arg.layout.align.bytes() == 16;
123 let double_word_count = arg.layout.size.bytes_usize().div_ceil(8);
125 let start_double_word_count = *total_double_word_count + usize::from(pad);
127
128 if arg.layout.pass_indirectly_in_non_rustic_abis(cx) {
129 arg.make_indirect();
130 *total_double_word_count += 1;
131 return;
132 }
133
134 if !arg.layout.is_aggregate() {
135 arg.extend_integer_width_to(64);
136 *total_double_word_count = start_double_word_count + double_word_count;
137 return;
138 }
139
140 let total = arg.layout.size;
141 if total > in_registers_max {
142 arg.make_indirect();
143 *total_double_word_count += 1;
144 return;
145 }
146
147 *total_double_word_count = start_double_word_count + double_word_count;
148
149 if let Some(Numeric::Int(Integer::I8 | Integer::I16, _)) = arg.layout.complex_number(cx) {
151 arg.cast_to(Reg { kind: RegKind::Integer, size: total });
152 return;
153 }
154
155 const ARGUMENT_REGISTERS: usize = 8;
156
157 let mut double_words = [DoubleWord::Words([Word::Integer; 2]); ARGUMENT_REGISTERS / 2];
158 classify(cx, &arg.layout, Size::ZERO, &mut double_words);
159
160 let mut regs = ArrayVec::new();
161 let mut attrs = ArgAttribute::empty();
162
163 for (index, double_word) in double_words.into_iter().enumerate() {
164 if arg.layout.size.bytes_usize() <= index * 8 {
165 break;
166 }
167 match double_word {
168 DoubleWord::F128Start if (start_double_word_count + index).is_multiple_of(2) => {
170 regs.push(Reg::f128());
171 }
172 DoubleWord::F128Start => {
173 regs.push(Reg::i64());
179 regs.push(Reg::i64());
180 }
181 DoubleWord::F128End => {} DoubleWord::F64 => regs.push(Reg::f64()),
183 DoubleWord::Words([Word::Integer, Word::Integer]) => regs.push(Reg::i64()),
184 DoubleWord::Words(words) => {
185 attrs |= ArgAttribute::InReg;
186 for word in words {
187 match word {
188 Word::F32 => regs.push(Reg::f32()),
189 Word::Integer => regs.push(Reg::i32()),
190 }
191 }
192 }
193 }
194 }
195
196 let cast_target = match regs.as_slice() {
197 [reg] => CastTarget::from(*reg),
199 _ => CastTarget::prefixed(regs, Uniform::new(Reg::i8(), Size::ZERO)),
200 };
201
202 arg.cast_to_and_pad_i32(cast_target.with_attrs(attrs.into()), u8::from(pad));
203}
204
205pub(crate) fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
206where
207 Ty: TyAbiInterface<'a, C> + Copy,
208 C: HasDataLayout + HasTargetSpec,
209{
210 if !fn_abi.ret.is_ignore() && fn_abi.ret.layout.is_sized() {
211 classify_arg(cx, &mut fn_abi.ret, Size::from_bytes(32), &mut 0);
213 }
214
215 let passes_zsts = #[allow(non_exhaustive_omitted_patterns)] match cx.target_spec().os {
Os::Linux => true,
_ => false,
}matches!(cx.target_spec().os, Os::Linux);
217
218 let mut double_word_count = 0;
219 for arg in fn_abi.args.iter_mut() {
220 if !arg.layout.is_sized() {
221 continue;
222 }
223 if arg.is_ignore() {
224 if passes_zsts && arg.layout.is_repr_c() {
225 arg.make_indirect_from_ignore();
226 double_word_count += 1;
227 }
228 continue;
229 }
230 classify_arg(cx, arg, Size::from_bytes(16), &mut double_word_count);
232 }
233}