src/librustc_trans/cabi_aarch64.rs

   1 // Copyright 2015 The Rust Project Developers. See the COPYRIGHT
   2 // file at the top-level directory of this distribution and at
   3 // http://rust-lang.org/COPYRIGHT.
   4 //
   5 // Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
   6 // http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
   7 // <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
   8 // option. This file may not be copied, modified, or distributed
   9 // except according to those terms.
  10
  11 #![allow(non_upper_case_globals)]
  12
  13 use llvm::{Integer, Pointer, Float, Double, Struct, Array, Vector};
  14 use abi::{self, FnType, ArgType};
  15 use context::CrateContext;
  16 use type_::Type;
  17
  18 fn ty_size(ty: Type) -> usize {
  19     abi::ty_size(ty, 8)
  20 }
  21
  22 fn is_homogenous_aggregate_ty(ty: Type) -> Option<(Type, u64)> {
  23     fn check_array(ty: Type) -> Option<(Type, u64)> {
  24         let len = ty.array_length() as u64;
  25         if len == 0 {
  26             return None
  27         }
  28         let elt = ty.element_type();
  29
  30         // if our element is an HFA/HVA, so are we; multiply members by our len
  31         is_homogenous_aggregate_ty(elt).map(|(base_ty, members)| (base_ty, len * members))
  32     }
  33
  34     fn check_struct(ty: Type) -> Option<(Type, u64)> {
  35         let str_tys = ty.field_types();
  36         if str_tys.len() == 0 {
  37             return None
  38         }
  39
  40         let mut prev_base_ty = None;
  41         let mut members = 0;
  42         for opt_homog_agg in str_tys.iter().map(|t| is_homogenous_aggregate_ty(*t)) {
  43             match (prev_base_ty, opt_homog_agg) {
  44                 // field isn't itself an HFA, so we aren't either
  45                 (_, None) => return None,
  46
  47                 // first field - store its type and number of members
  48                 (None, Some((field_ty, field_members))) => {
  49                     prev_base_ty = Some(field_ty);
  50                     members = field_members;
  51                 },
  52
  53                 // 2nd or later field - give up if it's a different type; otherwise incr. members
  54                 (Some(prev_ty), Some((field_ty, field_members))) => {
  55                     if prev_ty != field_ty {
  56                         return None;
  57                     }
  58                     members += field_members;
  59                 }
  60             }
  61         }
  62
  63         // Because of previous checks, we know prev_base_ty is Some(...) because
  64         //   1. str_tys has at least one element; and
  65         //   2. prev_base_ty was filled in (or we would've returned early)
  66         let (base_ty, members) = (prev_base_ty.unwrap(), members);
  67
  68         // Ensure there is no padding.
  69         if ty_size(ty) == ty_size(base_ty) * (members as usize) {
  70             Some((base_ty, members))
  71         } else {
  72             None
  73         }
  74     }
  75
  76     let homog_agg = match ty.kind() {
  77         Float  => Some((ty, 1)),
  78         Double => Some((ty, 1)),
  79         Array  => check_array(ty),
  80         Struct => check_struct(ty),
  81         Vector => match ty_size(ty) {
  82             4|8 => Some((ty, 1)),
  83             _   => None
  84         },
  85         _ => None
  86     };
  87
  88     // Ensure we have at most four uniquely addressable members
  89     homog_agg.and_then(|(base_ty, members)| {
  90         if members > 0 && members <= 4 {
  91             Some((base_ty, members))
  92         } else {
  93             None
  94         }
  95     })
  96 }
  97
  98 fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {
  99     if is_reg_ty(ret.ty) {
 100         ret.extend_integer_width_to(32);
 101         return;
 102     }
 103     if let Some((base_ty, members)) = is_homogenous_aggregate_ty(ret.ty) {
 104         ret.cast = Some(Type::array(&base_ty, members));
 105         return;
 106     }
 107     let size = ty_size(ret.ty);
 108     if size <= 16 {
 109         let llty = if size <= 1 {
 110             Type::i8(ccx)
 111         } else if size <= 2 {
 112             Type::i16(ccx)
 113         } else if size <= 4 {
 114             Type::i32(ccx)
 115         } else if size <= 8 {
 116             Type::i64(ccx)
 117         } else {
 118             Type::array(&Type::i64(ccx), ((size + 7 ) / 8 ) as u64)
 119         };
 120         ret.cast = Some(llty);
 121         return;
 122     }
 123     ret.make_indirect(ccx);
 124 }
 125
 126 fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType) {
 127     if is_reg_ty(arg.ty) {
 128         arg.extend_integer_width_to(32);
 129         return;
 130     }
 131     if let Some((base_ty, members)) = is_homogenous_aggregate_ty(arg.ty) {
 132         arg.cast = Some(Type::array(&base_ty, members));
 133         return;
 134     }
 135     let size = ty_size(arg.ty);
 136     if size <= 16 {
 137         let llty = if size == 0 {
 138             Type::array(&Type::i64(ccx), 0)
 139         } else if size == 1 {
 140             Type::i8(ccx)
 141         } else if size == 2 {
 142             Type::i16(ccx)
 143         } else if size <= 4 {
 144             Type::i32(ccx)
 145         } else if size <= 8 {
 146             Type::i64(ccx)
 147         } else {
 148             Type::array(&Type::i64(ccx), ((size + 7 ) / 8 ) as u64)
 149         };
 150         arg.cast = Some(llty);
 151         return;
 152     }
 153     arg.make_indirect(ccx);
 154 }
 155
 156 fn is_reg_ty(ty: Type) -> bool {
 157     match ty.kind() {
 158         Integer
 159         | Pointer
 160         | Float
 161         | Double
 162         | Vector => true,
 163         _ => false
 164     }
 165 }
 166
 167 pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {
 168     if !fty.ret.is_ignore() {
 169         classify_ret_ty(ccx, &mut fty.ret);
 170     }
 171
 172     for arg in &mut fty.args {
 173         if arg.is_ignore() { continue; }
 174         classify_arg_ty(ccx, arg);
 175     }
 176 }