Skip to main content

rustc_target/callconv/
sparc64.rs

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// NOTE: GCC and Clang/LLVM have disagreements that the ABI doesn't resolve, we match the
11// Clang/LLVM behavior in these cases.
12
13#[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    // If this function does not update the `double_words` array, the value will be passed via
37    // integer registers. The array is initialized with `DoubleWord::Words([Word::Integer; 2])`.
38
39    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                            // Match LLVM by passing `f16` in integer registers.
60                        }
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                    /* pass unaligned floats in integer registers */
67                }
68            }
69            Primitive::Int(_, _) | Primitive::Pointer(_) => { /* pass in integer registers */ }
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                    // Match Clang by ignoring whether a struct is packed and just considering
90                    // whether individual fields are aligned. GCC currently uses only integer
91                    // registers when passing packed structs.
92                    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    // 64-bit SPARC allocates argument stack space in 64-bit chunks (double words), some of which
116    // are promoted to registers based on their position on the stack.
117
118    // Keep track of the total number of double words used by arguments so far. This allows padding
119    // arguments to be inserted where necessary to ensure that 16-aligned arguments are passed in an
120    // aligned set of registers.
121
122    let pad = !total_double_word_count.is_multiple_of(2) && arg.layout.align.bytes() == 16;
123    // The number of double words used by this argument.
124    let double_word_count = arg.layout.size.bytes_usize().div_ceil(8);
125    // The number of double words before this argument, including any padding.
126    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    // Compatible with GCC and Clang 24.
150    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            // `f128` must be aligned to be assigned a float register.
169            DoubleWord::F128Start if (start_double_word_count + index).is_multiple_of(2) => {
170                regs.push(Reg::f128());
171            }
172            DoubleWord::F128Start => {
173                // Clang currently handles this case nonsensically, always returning a packed
174                // `struct { long double x; }` in an aligned quad floating-point register even when
175                // the `long double` isn't aligned on the stack, which also makes all future
176                // arguments get passed in the wrong registers. This passes the `f128` in integer
177                // registers when it is unaligned, same as with `f32` and `f64`.
178                regs.push(Reg::i64());
179                regs.push(Reg::i64());
180            }
181            DoubleWord::F128End => {} // Already handled by `F128Start`
182            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        // Just a single register is needed for this value.
198        [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        // A return value of 32 bytes or smaller is passed via registers.
212        classify_arg(cx, &mut fn_abi.ret, Size::from_bytes(32), &mut 0);
213    }
214
215    // sparc64-unknown-linux-{gnu,musl,uclibc} doesn't ignore ZSTs.
216    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        // An argument of 16 bytes or smaller is passed via registers.
231        classify_arg(cx, arg, Size::from_bytes(16), &mut double_word_count);
232    }
233}