rust/src/librustc/middle/trans/cabi_mips.rs

220 lines
5.8 KiB
Rust
Raw Normal View History

// Copyright 2012-2013 The Rust Project Developers. See the COPYRIGHT
2013-01-29 11:31:50 -06:00
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use core::prelude::*;
2013-01-29 11:31:50 -06:00
use core::libc::c_uint;
use core::ptr;
use core::uint;
use core::vec;
2013-06-15 09:29:52 -05:00
use lib::llvm::{llvm, Integer, Pointer, Float, Double, Struct, Array};
use lib::llvm::struct_tys;
use lib::llvm::{Attribute, StructRetAttribute};
use lib::llvm::True;
2013-06-14 00:38:17 -05:00
use middle::trans::context::task_llcx;
2013-01-29 11:31:50 -06:00
use middle::trans::common::*;
use middle::trans::cabi::*;
fn align_up_to(off: uint, a: uint) -> uint {
return (off + a - 1u) / a * a;
}
2013-06-15 09:29:52 -05:00
fn align(off: uint, ty: Type) -> uint {
2013-01-29 11:31:50 -06:00
let a = ty_align(ty);
return align_up_to(off, a);
}
2013-06-15 22:45:48 -05:00
fn ty_align(ty: Type) -> uint {
2013-01-29 11:31:50 -06:00
unsafe {
return match llvm::LLVMGetTypeKind(ty) {
Integer => {
((llvm::LLVMGetIntTypeWidth(ty) as uint) + 7) / 8
}
Pointer => 4,
Float => 4,
Double => 8,
Struct => {
2013-06-15 22:45:48 -05:00
if ty.is_packed() {
1
} else {
let str_tys = struct_tys(ty);
str_tys.iter().fold(1, |a, t| uint::max(a, ty_align(*t)))
2013-01-29 11:31:50 -06:00
}
}
Array => {
let elt = llvm::LLVMGetElementType(ty);
ty_align(elt)
}
_ => fail!("ty_size: unhandled type")
2013-01-29 11:31:50 -06:00
};
}
}
fn ty_size(ty: TypeRef) -> uint {
unsafe {
return match llvm::LLVMGetTypeKind(ty) {
Integer => {
((llvm::LLVMGetIntTypeWidth(ty) as uint) + 7) / 8
}
Pointer => 4,
Float => 4,
Double => 8,
Struct => {
if llvm::LLVMIsPackedStruct(ty) == True {
let str_tys = struct_tys(ty);
str_tys.iter().fold(0, |s, t| s + ty_size(*t))
} else {
2013-06-15 22:45:48 -05:00
let str_tys = ty.field_types();
let size = str_tys.iter().fold(0, |s, t| align(s, *t) + ty_size(*t));
align(size, ty)
}
2013-01-29 11:31:50 -06:00
}
Array => {
2013-06-15 22:45:48 -05:00
let len = ty.array_length();
let elt = ty.element_type();
let eltsz = ty_size(elt);
len * eltsz
2013-01-29 11:31:50 -06:00
}
_ => fail!("ty_size: unhandled type")
2013-01-29 11:31:50 -06:00
};
}
}
2013-06-15 22:45:48 -05:00
fn classify_ret_ty(ty: Type) -> (LLVMType, Option<Attribute>) {
2013-01-29 11:31:50 -06:00
return if is_reg_ty(ty) {
(LLVMType { cast: false, ty: ty }, None)
} else {
2013-06-15 22:45:48 -05:00
(LLVMType { cast: false, ty: ty.ptr_to() }, Some(StructRetAttribute))
2013-01-29 11:31:50 -06:00
};
}
2013-06-15 22:45:48 -05:00
fn classify_arg_ty(ty: Type, offset: &mut uint) -> (LLVMType, Option<Attribute>) {
2013-01-29 11:31:50 -06:00
let orig_offset = *offset;
let size = ty_size(ty) * 8;
let mut align = ty_align(ty);
align = uint::min(uint::max(align, 4), 8);
*offset = align_up_to(*offset, align);
*offset += align_up_to(size, align * 8) / 8;
let padding = padding_ty(align, orig_offset);
return if !is_reg_ty(ty) {
(LLVMType {
cast: true,
ty: struct_ty(ty, padding, true)
}, None)
} else if padding.is_some() {
(LLVMType {
cast: true,
ty: struct_ty(ty, padding, false)
}, None)
} else {
(LLVMType { cast: false, ty: ty }, None)
};
}
fn is_reg_ty(ty: TypeRef) -> bool {
unsafe {
2013-06-15 22:45:48 -05:00
return match ty.kind() {
2013-01-29 11:31:50 -06:00
Integer
| Pointer
| Float
| Double => true,
_ => false
};
}
}
2013-06-15 22:45:48 -05:00
fn padding_ty(align: uint, offset: uint) -> Option<Type> {
2013-01-29 11:31:50 -06:00
if ((align - 1 ) & offset) > 0 {
2013-06-15 22:45:48 -05:00
return Some(Type::i32());
2013-01-29 11:31:50 -06:00
}
return None;
}
2013-06-15 22:45:48 -05:00
fn coerce_to_int(size: uint) -> ~[Type] {
let int_ty = Type::i32();
2013-01-29 11:31:50 -06:00
let mut args = ~[];
let mut n = size / 32;
while n > 0 {
args.push(int_ty);
n -= 1;
}
let r = size % 32;
if r > 0 {
unsafe {
2013-06-15 22:45:48 -05:00
Type::from_ref(args.push(llvm::LLVMIntTypeInContext(task_llcx(), r as c_uint)))
2013-01-29 11:31:50 -06:00
}
}
return args;
}
2013-06-15 22:45:48 -05:00
fn struct_ty(ty: Type,
padding: Option<Type>,
coerce: bool) -> Type {
2013-01-29 11:31:50 -06:00
let size = ty_size(ty) * 8;
let mut fields = padding.map_default(~[], |p| ~[*p]);
if coerce {
fields = vec::append(fields, coerce_to_int(size));
} else {
fields.push(ty);
}
2013-06-15 22:45:48 -05:00
return Type::struct_(fields, false);
2013-01-29 11:31:50 -06:00
}
enum MIPS_ABIInfo { MIPS_ABIInfo }
impl ABIInfo for MIPS_ABIInfo {
fn compute_info(&self,
2013-06-15 22:45:48 -05:00
atys: &[Type],
rty: Type,
2013-01-29 11:31:50 -06:00
ret_def: bool) -> FnType {
let mut (ret_ty, ret_attr) = if ret_def {
classify_ret_ty(rty)
} else {
2013-06-15 22:45:48 -05:00
(LLVMType { cast: false, ty: Type::void() }, None)
2013-01-29 11:31:50 -06:00
};
let sret = ret_attr.is_some();
let mut arg_tys = ~[];
let mut attrs = ~[];
let mut offset = if sret { 4 } else { 0 };
for atys.each() |aty| {
let (ty, attr) = classify_arg_ty(*aty, &mut offset);
arg_tys.push(ty);
attrs.push(attr);
};
if sret {
arg_tys = vec::append(~[ret_ty], arg_tys);
attrs = vec::append(~[ret_attr], attrs);
2013-06-15 22:45:48 -05:00
ret_ty = LLVMType { cast: false, ty: Type::void() };
2013-01-29 11:31:50 -06:00
}
return FnType {
arg_tys: arg_tys,
ret_ty: ret_ty,
attrs: attrs,
sret: sret
};
}
}
pub fn abi_info() -> @ABIInfo {
2013-01-29 11:31:50 -06:00
return @MIPS_ABIInfo as @ABIInfo;
}