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.
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.
11 #![allow(non_uppercase_pattern_statics)]
16 use llvm::{Integer, Pointer, Float, Double, Struct, Array};
17 use llvm::{StructRetAttribute, ZExtAttribute};
18 use middle::trans::context::CrateContext;
19 use middle::trans::cabi::*;
20 use middle::trans::type_::Type;
22 fn align_up_to(off: uint, a: uint) -> uint {
23 return (off + a - 1u) / a * a;
26 fn align(off: uint, ty: Type) -> uint {
28 return align_up_to(off, a);
31 fn ty_align(ty: Type) -> uint {
35 ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
45 let str_tys = ty.field_types();
46 str_tys.iter().fold(1, |a, t| cmp::max(a, ty_align(*t)))
50 let elt = ty.element_type();
53 _ => fail!("ty_size: unhandled type")
57 fn ty_size(ty: Type) -> uint {
61 ((llvm::LLVMGetIntTypeWidth(ty.to_ref()) as uint) + 7) / 8
69 let str_tys = ty.field_types();
70 str_tys.iter().fold(0, |s, t| s + ty_size(*t))
72 let str_tys = ty.field_types();
73 let size = str_tys.iter().fold(0, |s, t| align(s, *t) + ty_size(*t));
78 let len = ty.array_length();
79 let elt = ty.element_type();
80 let eltsz = ty_size(elt);
83 _ => fail!("ty_size: unhandled type")
87 fn classify_ret_ty(ccx: &CrateContext, ty: Type) -> ArgType {
89 let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
90 ArgType::direct(ty, None, None, attr)
92 ArgType::indirect(ty, Some(StructRetAttribute))
96 fn classify_arg_ty(ccx: &CrateContext, ty: Type, offset: &mut uint) -> ArgType {
97 let orig_offset = *offset;
98 let size = ty_size(ty) * 8;
99 let mut align = ty_align(ty);
101 align = cmp::min(cmp::max(align, 4), 8);
102 *offset = align_up_to(*offset, align);
103 *offset += align_up_to(size, align * 8) / 8;
106 let attr = if ty == Type::i1(ccx) { Some(ZExtAttribute) } else { None };
107 ArgType::direct(ty, None, None, attr)
111 Some(struct_ty(ccx, ty)),
112 padding_ty(ccx, align, orig_offset),
118 fn is_reg_ty(ty: Type) -> bool {
119 return match ty.kind() {
128 fn padding_ty(ccx: &CrateContext, align: uint, offset: uint) -> Option<Type> {
129 if ((align - 1 ) & offset) > 0 {
136 fn coerce_to_int(ccx: &CrateContext, size: uint) -> Vec<Type> {
137 let int_ty = Type::i32(ccx);
138 let mut args = Vec::new();
140 let mut n = size / 32;
149 args.push(Type::from_ref(llvm::LLVMIntTypeInContext(ccx.llcx, r as c_uint)));
156 fn struct_ty(ccx: &CrateContext, ty: Type) -> Type {
157 let size = ty_size(ty) * 8;
158 Type::struct_(ccx, coerce_to_int(ccx, size).as_slice(), false)
161 pub fn compute_abi_info(ccx: &CrateContext,
164 ret_def: bool) -> FnType {
165 let ret_ty = if ret_def {
166 classify_ret_ty(ccx, rty)
168 ArgType::direct(Type::void(ccx), None, None, None)
171 let sret = ret_ty.is_indirect();
172 let mut arg_tys = Vec::new();
173 let mut offset = if sret { 4 } else { 0 };
175 for aty in atys.iter() {
176 let ty = classify_arg_ty(ccx, *aty, &mut offset);