src/librustc_trans/cabi_sparc.rs

   1 // Copyright 2012-2013 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 libc::c_uint;
  14 use std::cmp;
  15 use llvm;
  16 use llvm::{Integer, Pointer, Float, Double, Vector};
  17 use abi::{self, align_up_to, ArgType, FnType};
  18 use context::CrateContext;
  19 use type_::Type;
  20
  21 fn ty_align(ty: Type) -> usize {
  22     abi::ty_align(ty, 4)
  23 }
  24
  25 fn ty_size(ty: Type) -> usize {
  26     abi::ty_size(ty, 4)
  27 }
  28
  29 fn classify_ret_ty(ccx: &CrateContext, ret: &mut ArgType) {
  30     if is_reg_ty(ret.ty) {
  31         ret.extend_integer_width_to(32);
  32     } else {
  33         ret.make_indirect(ccx);
  34     }
  35 }
  36
  37 fn classify_arg_ty(ccx: &CrateContext, arg: &mut ArgType, offset: &mut usize) {
  38     let orig_offset = *offset;
  39     let size = ty_size(arg.ty) * 8;
  40     let mut align = ty_align(arg.ty);
  41
  42     align = cmp::min(cmp::max(align, 4), 8);
  43     *offset = align_up_to(*offset, align);
  44     *offset += align_up_to(size, align * 8) / 8;
  45
  46     if !is_reg_ty(arg.ty) {
  47         arg.cast = Some(struct_ty(ccx, arg.ty));
  48         arg.pad = padding_ty(ccx, align, orig_offset);
  49     } else {
  50         arg.extend_integer_width_to(32);
  51     }
  52 }
  53
  54 fn is_reg_ty(ty: Type) -> bool {
  55     return match ty.kind() {
  56         Integer
  57         | Pointer
  58         | Float
  59         | Double
  60         | Vector => true,
  61         _ => false
  62     };
  63 }
  64
  65 fn padding_ty(ccx: &CrateContext, align: usize, offset: usize) -> Option<Type> {
  66     if ((align - 1 ) & offset) > 0 {
  67         Some(Type::i32(ccx))
  68     } else {
  69         None
  70     }
  71 }
  72
  73 fn coerce_to_int(ccx: &CrateContext, size: usize) -> Vec<Type> {
  74     let int_ty = Type::i32(ccx);
  75     let mut args = Vec::new();
  76
  77     let mut n = size / 32;
  78     while n > 0 {
  79         args.push(int_ty);
  80         n -= 1;
  81     }
  82
  83     let r = size % 32;
  84     if r > 0 {
  85         unsafe {
  86             args.push(Type::from_ref(llvm::LLVMIntTypeInContext(ccx.llcx(), r as c_uint)));
  87         }
  88     }
  89
  90     args
  91 }
  92
  93 fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {
  94     let size = ty_size(ty) * 8;
  95     Type::struct_(ccx, &coerce_to_int(ccx, size), false)
  96 }
  97
  98 pub fn compute_abi_info(ccx: &CrateContext, fty: &mut FnType) {
  99     if !fty.ret.is_ignore() {
 100         classify_ret_ty(ccx, &mut fty.ret);
 101     }
 102
 103     let mut offset = if fty.ret.is_indirect() { 4 } else { 0 };
 104     for arg in &mut fty.args {
 105         if arg.is_ignore() { continue; }
 106         classify_arg_ty(ccx, arg, &mut offset);
 107     }
 108 }