1 // Copyright 2014-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.
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.
13 use llvm::{Integer, Pointer, Float, Double, Struct, Array};
14 use llvm::{StructRetAttribute, ZExtAttribute};
15 use trans::cabi::{FnType, ArgType};
16 use trans::context::CrateContext;
17 use trans::type_::Type;
21 fn align_up_to(off: uint, a: uint) -> uint {
22 return (off + a - 1) / a * a;
25 fn align(off: uint, ty: Type) -> uint {
27 return align_up_to(off, a);
30 fn ty_align(ty: Type) -> uint {
34 ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
44 let str_tys = ty.field_types();
45 str_tys.iter().fold(1, |a, t| cmp::max(a, ty_align(*t)))
49 let elt = ty.element_type();
52 _ => panic!("ty_size: unhandled type")
56 fn ty_size(ty: Type) -> uint {
60 ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
68 let str_tys = ty.field_types();
69 str_tys.iter().fold(0, |s, t| s + ty_size(*t))
71 let str_tys = ty.field_types();
72 let size = str_tys.iter().fold(0, |s, t| align(s, *t) + ty_size(*t));
77 let len = ty.array_length();
78 let elt = ty.element_type();
79 let eltsz = ty_size(elt);
82 _ => panic!("ty_size: unhandled type")
86 fn classify_ret_ty(ccx: &CrateContext, ty: Type) -> ArgType {
88 let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
89 ArgType::direct(ty, None, None, attr)
91 ArgType::indirect(ty, Some(StructRetAttribute))
95 fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut uint) -> ArgType {
96 let orig_offset = *offset;
97 let size = ty_size(ty) * 8;
98 let mut align = ty_align(ty);
100 align = cmp::min(cmp::max(align, 4), 8);
101 *offset = align_up_to(*offset, align);
102 *offset += align_up_to(size, align * 8) / 8;
105 let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
106 ArgType::direct(ty, None, None, attr)
110 Some(struct_ty(ccx, ty)),
111 padding_ty(ccx, align, orig_offset),
117 fn is_reg_ty(ty: Type) -> bool {
118 return match ty.kind() {
127 fn padding_ty(ccx: &CrateContext, align: uint, offset: uint) -> Option<Type> {
128 if ((align - 1 ) & offset) > 0 {
135 fn coerce_to_int(ccx: &CrateContext, size: uint) -> Vec<Type> {
136 let int_ty = Type::i32(ccx);
137 let mut args = Vec::new();
139 let mut n = size / 32;
148 args.push(Type::from_ref(llvm::LLVMIntTypeInContext(ccx.llcx(), r as c_uint)));
155 fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {
156 let size = ty_size(ty) * 8;
157 Type::struct_(ccx, coerce_to_int(ccx, size).as_slice(), false)
160 pub fn compute_abi_info(ccx: &CrateContext,
163 ret_def: bool) -> FnType {
164 let ret_ty = if ret_def {
165 classify_ret_ty(ccx, rty)
167 ArgType::direct(Type::void(ccx), None, None, None)
170 let sret = ret_ty.is_indirect();
171 let mut arg_tys = Vec::new();
172 let mut offset = if sret { 4 } else { 0 };
175 let ty = classify_arg_ty(ccx, *aty, &mut offset);