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

464 lines
18 KiB
Rust
Raw Normal View History

// Translation of automatically-derived trait implementations. This handles
// enums and structs only; other types cannot be automatically derived.
use lib::llvm::llvm::{LLVMCountParams, LLVMGetParam};
use middle::trans::base::{GEP_enum, finish_fn, get_insn_ctxt, get_item_val};
use middle::trans::base::{new_fn_ctxt, sub_block, top_scope_block};
use middle::trans::base;
use middle::trans::build::{AddCase, Br, CondBr, GEPi, Load, PointerCast};
use middle::trans::build::{Store, Switch, Unreachable, ValueRef};
use middle::trans::callee;
use middle::trans::callee::{ArgVals, Callee, DontAutorefArg, Method};
use middle::trans::callee::{MethodData};
use middle::trans::common;
use middle::trans::common::{C_bool, C_int, T_ptr, block, crate_ctxt};
use middle::trans::common::{fn_ctxt};
use middle::trans::expr::SaveIn;
use middle::trans::type_of::type_of;
use middle::ty::{DerivedFieldInfo, re_static};
use middle::typeck::check::method;
use middle::typeck::method_static;
use syntax::ast;
use syntax::ast::{def_id, ident, node_id, ty_param};
use syntax::ast_map::path;
use syntax::ast_util;
use syntax::ast_util::local_def;
use core::dvec::DVec;
use core::dvec;
use core::libc::c_uint;
/// The kind of deriving method this is.
enum DerivingKind {
2012-11-13 13:30:37 -06:00
BoolKind, // fn f(&self, other: &other) -> bool
UnitKind, // fn f(&self) -> ()
}
impl DerivingKind {
static fn of_item(ccx: @crate_ctxt, method_did: ast::def_id)
-> DerivingKind {
let item_type = ty::lookup_item_type(ccx.tcx, method_did).ty;
match ty::get(item_type).sty {
ty::ty_fn(ref f) => {
match ty::get(f.sig.output).sty {
ty::ty_bool => BoolKind,
ty::ty_nil => UnitKind,
_ => {
// FIXME (#3957): Report this earlier.
ccx.tcx.sess.fatal(~"attempt to automatically derive \
derive an implementation of a \
function returning something \
other than bool or ()");
}
}
}
_ => {
ccx.tcx.sess.bug(~"DerivingKind::of_item(): method def ID \
didn't have a function type");
}
}
}
}
/// The main "translation" pass for the automatically-derived methods in
/// an impl. Generates code for monomorphic methods only. Other methods will
/// be generated when they are invoked with specific type parameters; see
/// `trans::base::lval_static_fn()` or `trans::base::monomorphic_fn()`.
pub fn trans_deriving_impl(ccx: @crate_ctxt,
_path: path,
_name: ident,
tps: ~[ty_param],
id: node_id) {
let _icx = ccx.insn_ctxt("deriving::trans_deriving_impl");
if tps.len() > 0 { return; }
let impl_def_id = local_def(id);
let self_ty = ty::lookup_item_type(ccx.tcx, impl_def_id);
match ccx.tcx.automatically_derived_methods_for_impl.find(impl_def_id) {
Some(copy method_dids) => {
for method_dids.each |method_did| {
let kind = DerivingKind::of_item(ccx, *method_did);
let llfn = get_item_val(ccx, method_did.node);
// Transform the self type as appropriate.
let derived_method_info =
ccx.tcx.automatically_derived_methods.get(*method_did);
let transformed_self_ty =
method::transform_self_type_for_method(
ccx.tcx,
Some(re_static),
self_ty.ty,
derived_method_info.method_info.self_type);
match ty::get(self_ty.ty).sty {
ty::ty_class(*) => {
trans_deriving_struct_method(ccx,
llfn,
impl_def_id,
self_ty.ty,
transformed_self_ty,
kind);
}
ty::ty_enum(*) => {
trans_deriving_enum_method(ccx,
llfn,
impl_def_id,
self_ty.ty,
transformed_self_ty,
kind);
}
_ => {
ccx.tcx.sess.bug(~"translation of non-struct \
deriving method");
}
}
}
}
None => {} // Nothing to do.
}
}
fn get_extra_params(llfn: ValueRef, kind: DerivingKind) -> ~[ValueRef] {
let n_params = LLVMCountParams(llfn) as uint;
let initial_extra_param;
match kind {
BoolKind => initial_extra_param = 3,
UnitKind => initial_extra_param = 2,
}
let extra_params = DVec();
for uint::range(initial_extra_param, n_params) |i| {
extra_params.push(LLVMGetParam(llfn, i as c_uint));
}
return dvec::unwrap(move extra_params);
}
fn trans_deriving_struct_method(ccx: @crate_ctxt,
llfn: ValueRef,
impl_did: def_id,
self_ty: ty::t,
transformed_self_ty: ty::t,
kind: DerivingKind) {
let _icx = ccx.insn_ctxt("trans_deriving_struct_method");
let fcx = new_fn_ctxt(ccx, ~[], llfn, None);
let top_bcx = top_scope_block(fcx, None);
let lltop = top_bcx.llbb;
let mut bcx = top_bcx;
let llextraparams = get_extra_params(llfn, kind);
let lltransformedselfty = type_of(ccx, transformed_self_ty);
let lltransformedselfval =
PointerCast(bcx, fcx.llenv, T_ptr(lltransformedselfty));
let llselfval = Load(bcx, lltransformedselfval);
// If there is an "other" value, then get it. The "other" value is the
// value we're comparing against in the case of Eq and Ord.
let llotherval_opt;
match kind {
BoolKind => llotherval_opt = Some(LLVMGetParam(llfn, 2)),
UnitKind => llotherval_opt = None
}
let struct_field_tys;
match ty::get(self_ty).sty {
ty::ty_class(struct_id, ref struct_substs) => {
struct_field_tys = ty::class_items_as_fields(
ccx.tcx, struct_id, struct_substs);
}
_ => {
ccx.tcx.sess.bug(~"passed non-struct to \
trans_deriving_struct_method");
}
}
// Iterate over every element of the struct.
for ccx.tcx.deriving_struct_methods.get(impl_did).eachi
|i, derived_method_info| {
let llselfval = GEPi(bcx, llselfval, [0, 0, i]);
let llselfallocaty = common::val_ty(llselfval);
let llselfalloca = base::alloca(bcx, llselfallocaty);
Store(bcx, llselfval, llselfalloca);
let llotherval_opt = llotherval_opt.map(
|llotherval| GEPi(bcx, *llotherval, [0, 0, i]));
let self_ty = struct_field_tys[i].mt.ty;
bcx = call_substructure_method(bcx,
derived_method_info,
self_ty,
llselfalloca,
llotherval_opt,
llextraparams);
// If this derived method is of boolean kind, return immediately if
// the call to the substructure method returned false.
match kind {
BoolKind => {
let next_block = sub_block(top_bcx, ~"next");
let llcond = Load(bcx, fcx.llretptr);
CondBr(bcx, llcond, next_block.llbb, fcx.llreturn);
bcx = next_block;
}
UnitKind => {} // Unconditionally continue.
}
}
// Store true if necessary.
match kind {
BoolKind => Store(bcx, C_bool(true), fcx.llretptr),
UnitKind => {}
}
Br(bcx, fcx.llreturn);
finish_fn(fcx, lltop);
}
// This could have been combined with trans_deriving_struct_method, but it
// would probably be too big and hard to understand.
fn trans_deriving_enum_method(ccx: @crate_ctxt,
llfn: ValueRef,
impl_did: def_id,
self_ty: ty::t,
transformed_self_ty: ty::t,
kind: DerivingKind) {
let _icx = ccx.insn_ctxt("trans_deriving_enum_method");
let fcx = new_fn_ctxt(ccx, ~[], llfn, None);
let top_bcx = top_scope_block(fcx, None);
let lltop = top_bcx.llbb;
let mut bcx = top_bcx;
let llextraparams = get_extra_params(llfn, kind);
let lltransformedselfty = type_of(ccx, transformed_self_ty);
let lltransformedselfval =
PointerCast(bcx, fcx.llenv, T_ptr(lltransformedselfty));
let llselfval = Load(bcx, lltransformedselfval);
let llotherval_opt;
match kind {
UnitKind => llotherval_opt = None,
BoolKind => llotherval_opt = Some(LLVMGetParam(llfn, 2))
}
let enum_id, enum_substs, enum_variant_infos;
match ty::get(self_ty).sty {
ty::ty_enum(found_enum_id, ref found_enum_substs) => {
enum_id = found_enum_id;
enum_substs = copy *found_enum_substs;
enum_variant_infos = ty::substd_enum_variants(
ccx.tcx, enum_id, &enum_substs);
}
_ => {
ccx.tcx.sess.bug(~"passed non-enum to \
trans_deriving_enum_method");
}
}
// Create the "no match" basic block, if necessary. This is a basic block
// that does nothing more than return false.
let nomatch_bcx_opt;
match kind {
BoolKind => {
let nomatch_bcx = sub_block(top_bcx, ~"no_match");
Store(nomatch_bcx, C_bool(false), fcx.llretptr);
Br(nomatch_bcx, fcx.llreturn);
nomatch_bcx_opt = Some(nomatch_bcx);
}
UnitKind => nomatch_bcx_opt = None
}
// Create the "unreachable" basic block.
let unreachable_bcx = sub_block(top_bcx, ~"unreachable");
Unreachable(unreachable_bcx);
// Get the deriving enum method info.
let deriving_enum_methods = ccx.tcx.deriving_enum_methods.get(impl_did);
let n_variants = deriving_enum_methods.len();
if n_variants != 1 {
// Grab the two discriminants.
let llselfdiscrim = Load(bcx, GEPi(bcx, llselfval, [0, 0]));
let llotherdiscrim_opt = llotherval_opt.map(
|llotherval| Load(bcx, GEPi(bcx, *llotherval, [0, 0])));
// Skip over the discriminants and compute the address of the payload.
let llselfpayload = GEPi(bcx, llselfval, [0, 1]);
let llotherpayload_opt = llotherval_opt.map(
|llotherval| GEPi(bcx, *llotherval, [0, 1]));
// Create basic blocks for the outer switch.
let outer_bcxs = vec::from_fn(
deriving_enum_methods.len(),
|i| sub_block(top_bcx, fmt!("outer_%u", i)));
// For each basic block in the outer switch...
for outer_bcxs.eachi |self_variant_index, bcx| {
// Create the matching basic block for the inner switch.
let top_match_bcx = sub_block(top_bcx, fmt!("maybe_match_%u",
self_variant_index));
let mut match_bcx = top_match_bcx;
// Compare each variant.
for deriving_enum_methods[self_variant_index].eachi
|i, derived_method_info| {
let variant_def_id =
enum_variant_infos[self_variant_index].id;
let llselfval = GEP_enum(match_bcx, llselfpayload, enum_id,
variant_def_id, enum_substs.tps, i);
let llselfallocaty = common::val_ty(llselfval);
let llselfalloca = base::alloca(match_bcx, llselfallocaty);
Store(match_bcx, llselfval, llselfalloca);
let llotherval_opt = llotherpayload_opt.map(|llotherpayload|
GEP_enum(match_bcx, *llotherpayload, enum_id,
variant_def_id, enum_substs.tps, i));
let self_ty = enum_variant_infos[self_variant_index].args[i];
match_bcx = call_substructure_method(match_bcx,
derived_method_info,
self_ty,
llselfalloca,
llotherval_opt,
llextraparams);
// If this is a boolean-kind deriving method, then return
// immediately if the call to the substructure returned false.
match kind {
BoolKind => {
let next_bcx = sub_block(top_bcx,
fmt!("next_%u_%u",
self_variant_index,
i));
let llcond = Load(match_bcx, fcx.llretptr);
CondBr(match_bcx,
llcond,
next_bcx.llbb,
fcx.llreturn);
match_bcx = next_bcx;
}
UnitKind => {}
}
}
// Store true in the return pointer if this is a boolean-kind
// deriving method.
match kind {
BoolKind => Store(match_bcx, C_bool(true), fcx.llretptr),
UnitKind => {}
}
// Finish up the matching block.
Br(match_bcx, fcx.llreturn);
// If this is a boolean-kind derived method, build the inner
// switch. Otherwise, just jump to the matching case.
match llotherdiscrim_opt {
None => Br(*bcx, top_match_bcx.llbb),
Some(copy llotherdiscrim) => {
let llswitch = Switch(*bcx,
llotherdiscrim,
unreachable_bcx.llbb,
n_variants);
for uint::range(0, n_variants) |other_variant_index| {
let discriminant =
enum_variant_infos[other_variant_index].disr_val;
if self_variant_index == other_variant_index {
// This is the potentially-matching case.
AddCase(llswitch,
C_int(ccx, discriminant),
top_match_bcx.llbb);
} else {
// This is always a non-matching case.
AddCase(llswitch,
C_int(ccx, discriminant),
nomatch_bcx_opt.get().llbb);
}
}
}
}
}
// Now build the outer switch.
let llswitch = Switch(top_bcx, llselfdiscrim, unreachable_bcx.llbb,
n_variants);
for outer_bcxs.eachi |self_variant_index, outer_bcx| {
let discriminant =
enum_variant_infos[self_variant_index].disr_val;
AddCase(llswitch, C_int(ccx, discriminant), outer_bcx.llbb);
}
} else {
ccx.tcx.sess.unimpl(~"degenerate enum deriving");
}
// Finish up the function.
finish_fn(fcx, lltop);
}
fn call_substructure_method(bcx: block,
derived_field_info: &DerivedFieldInfo,
self_ty: ty::t,
llselfval: ValueRef,
llotherval_opt: Option<ValueRef>,
llextraparams: &[ValueRef]) -> block {
let fcx = bcx.fcx;
let ccx = fcx.ccx;
let target_method_def_id;
match derived_field_info.method_origin {
method_static(did) => target_method_def_id = did,
_ => fail ~"derived method didn't resolve to a static method"
}
let fn_expr_tpbt = ty::lookup_item_type(ccx.tcx, target_method_def_id);
debug!("(calling substructure method) substructure method has %u \
parameter(s), vtable result is %?",
fn_expr_tpbt.bounds.len(),
derived_field_info.vtable_result);
// Get the substructure method we need to call. This may involve
// code generation in the case of generics, default methods, or cross-
// crate inlining.
let fn_data = callee::trans_fn_ref_with_vtables(bcx,
target_method_def_id,
0, // ref id
*derived_field_info.
type_parameter_substitutions,
derived_field_info.
vtable_result);
let llfn = fn_data.llfn;
// Create the callee.
let cb: &fn(block) -> Callee = |bloc| {
Callee {
bcx: bloc,
data: Method(MethodData {
llfn: llfn,
llself: llselfval,
self_ty: self_ty,
self_mode: ast::by_copy
})
}
};
// Build up the argument list.
let llargvals = DVec();
for llotherval_opt.each |llotherval| { llargvals.push(*llotherval); }
for llextraparams.each |llextraparam| { llargvals.push(*llextraparam); }
// And perform the call.
callee::trans_call_inner(bcx,
None,
fn_expr_tpbt.ty,
ty::mk_bool(ccx.tcx),
cb,
ArgVals(dvec::unwrap(move llargvals)),
SaveIn(fcx.llretptr),
DontAutorefArg)
}