src/librustc_target/abi/call/aarch64.rs

   1 use crate::abi::call::{ArgAbi, FnAbi, Reg, RegKind, Uniform};
   2 use crate::abi::{HasDataLayout, LayoutOf, TyLayout, TyLayoutMethods};
   3
   4 fn is_homogeneous_aggregate<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>) -> Option<Uniform>
   5 where
   6     Ty: TyLayoutMethods<'a, C> + Copy,
   7     C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout,
   8 {
   9     arg.layout.homogeneous_aggregate(cx).unit().and_then(|unit| {
  10         let size = arg.layout.size;
  11
  12         // Ensure we have at most four uniquely addressable members.
  13         if size > unit.size.checked_mul(4, cx).unwrap() {
  14             return None;
  15         }
  16
  17         let valid_unit = match unit.kind {
  18             RegKind::Integer => false,
  19             RegKind::Float => true,
  20             RegKind::Vector => size.bits() == 64 || size.bits() == 128,
  21         };
  22
  23         valid_unit.then_some(Uniform { unit, total: size })
  24     })
  25 }
  26
  27 fn classify_ret<'a, Ty, C>(cx: &C, ret: &mut ArgAbi<'a, Ty>)
  28 where
  29     Ty: TyLayoutMethods<'a, C> + Copy,
  30     C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout,
  31 {
  32     if !ret.layout.is_aggregate() {
  33         ret.extend_integer_width_to(32);
  34         return;
  35     }
  36     if let Some(uniform) = is_homogeneous_aggregate(cx, ret) {
  37         ret.cast_to(uniform);
  38         return;
  39     }
  40     let size = ret.layout.size;
  41     let bits = size.bits();
  42     if bits <= 128 {
  43         let unit = if bits <= 8 {
  44             Reg::i8()
  45         } else if bits <= 16 {
  46             Reg::i16()
  47         } else if bits <= 32 {
  48             Reg::i32()
  49         } else {
  50             Reg::i64()
  51         };
  52
  53         ret.cast_to(Uniform { unit, total: size });
  54         return;
  55     }
  56     ret.make_indirect();
  57 }
  58
  59 fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>)
  60 where
  61     Ty: TyLayoutMethods<'a, C> + Copy,
  62     C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout,
  63 {
  64     if !arg.layout.is_aggregate() {
  65         arg.extend_integer_width_to(32);
  66         return;
  67     }
  68     if let Some(uniform) = is_homogeneous_aggregate(cx, arg) {
  69         arg.cast_to(uniform);
  70         return;
  71     }
  72     let size = arg.layout.size;
  73     let bits = size.bits();
  74     if bits <= 128 {
  75         let unit = if bits <= 8 {
  76             Reg::i8()
  77         } else if bits <= 16 {
  78             Reg::i16()
  79         } else if bits <= 32 {
  80             Reg::i32()
  81         } else {
  82             Reg::i64()
  83         };
  84
  85         arg.cast_to(Uniform { unit, total: size });
  86         return;
  87     }
  88     arg.make_indirect();
  89 }
  90
  91 pub fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
  92 where
  93     Ty: TyLayoutMethods<'a, C> + Copy,
  94     C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout,
  95 {
  96     if !fn_abi.ret.is_ignore() {
  97         classify_ret(cx, &mut fn_abi.ret);
  98     }
  99
 100     for arg in &mut fn_abi.args {
 101         if arg.is_ignore() {
 102             continue;
 103         }
 104         classify_arg(cx, arg);
 105     }
 106 }