src/librustc_target/abi/call/aarch64.rs

   1 use crate::abi::call::{FnAbi, ArgAbi, 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>)
   5                                      -> Option<Uniform>
   6     where 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 Ty: TyLayoutMethods<'a, C> + Copy,
  29           C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout
  30 {
  31     if !ret.layout.is_aggregate() {
  32         ret.extend_integer_width_to(32);
  33         return;
  34     }
  35     if let Some(uniform) = is_homogeneous_aggregate(cx, ret) {
  36         ret.cast_to(uniform);
  37         return;
  38     }
  39     let size = ret.layout.size;
  40     let bits = size.bits();
  41     if bits <= 128 {
  42         let unit = if bits <= 8 {
  43             Reg::i8()
  44         } else if bits <= 16 {
  45             Reg::i16()
  46         } else if bits <= 32 {
  47             Reg::i32()
  48         } else {
  49             Reg::i64()
  50         };
  51
  52         ret.cast_to(Uniform {
  53             unit,
  54             total: size
  55         });
  56         return;
  57     }
  58     ret.make_indirect();
  59 }
  60
  61 fn classify_arg<'a, Ty, C>(cx: &C, arg: &mut ArgAbi<'a, Ty>)
  62     where Ty: TyLayoutMethods<'a, C> + Copy,
  63           C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout
  64 {
  65     if !arg.layout.is_aggregate() {
  66         arg.extend_integer_width_to(32);
  67         return;
  68     }
  69     if let Some(uniform) = is_homogeneous_aggregate(cx, arg) {
  70         arg.cast_to(uniform);
  71         return;
  72     }
  73     let size = arg.layout.size;
  74     let bits = size.bits();
  75     if bits <= 128 {
  76         let unit = if bits <= 8 {
  77             Reg::i8()
  78         } else if bits <= 16 {
  79             Reg::i16()
  80         } else if bits <= 32 {
  81             Reg::i32()
  82         } else {
  83             Reg::i64()
  84         };
  85
  86         arg.cast_to(Uniform {
  87             unit,
  88             total: size
  89         });
  90         return;
  91     }
  92     arg.make_indirect();
  93 }
  94
  95 pub fn compute_abi_info<'a, Ty, C>(cx: &C, fn_abi: &mut FnAbi<'a, Ty>)
  96     where Ty: TyLayoutMethods<'a, C> + Copy,
  97           C: LayoutOf<Ty = Ty, TyLayout = TyLayout<'a, Ty>> + HasDataLayout
  98 {
  99     if !fn_abi.ret.is_ignore() {
 100         classify_ret(cx, &mut fn_abi.ret);
 101     }
 102
 103     for arg in &mut fn_abi.args {
 104         if arg.is_ignore() { continue; }
 105         classify_arg(cx, arg);
 106     }
 107 }