OpenE2K
/
rust
2
0
Fork 0
Code Issues Pull Requests Projects Releases Wiki Activity

rustc: de-@ adt::Repr.

This commit is contained in:
Eduard Burtescu 2014-04-22 03:03:02 +03:00
parent 344ce17036
commit 938eaaa304
10 changed files with 61 additions and 59 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

29
src/librustc/middle/trans/_match.rs
View File

@ -225,6 +225,7 @@ use util::ppaux::{Repr, vec_map_to_str};
use collections::HashMap;
use std::cell::Cell;
use std::rc::Rc;
use syntax::ast;
use syntax::ast::Ident;
use syntax::ast_util::path_to_ident;
@ -250,7 +251,7 @@ pub enum VecLenOpt {
// range)
enum Opt {
lit(Lit),
var(ty::Disr, @adt::Repr),
var(ty::Disr, Rc<adt::Repr>),
range(@ast::Expr, @ast::Expr),
vec_len(/* length */ uint, VecLenOpt, /*range of matches*/(uint, uint))
}
@ -351,8 +352,8 @@ fn trans_opt<'a>(bcx: &'a Block<'a>, o: &Opt) -> opt_result<'a> {
let (llval, _) = consts::get_const_val(bcx.ccx(), lit_id);
return single_result(rslt(bcx, llval));
}
var(disr_val, repr) => {
return adt::trans_case(bcx, repr, disr_val);
var(disr_val, ref repr) => {
return adt::trans_case(bcx, &**repr, disr_val);
}
range(l1, l2) => {
let (l1, _) = consts::const_expr(ccx, l1, true);
@ -1561,7 +1562,7 @@ fn compile_submatch_continue<'a, 'b>(
expr::with_field_tys(tcx, pat_ty, Some(pat_id), |discr, field_tys| {
let rec_vals = rec_fields.iter().map(|field_name| {
let ix = ty::field_idx_strict(tcx, field_name.name, field_tys);
adt::trans_field_ptr(bcx, pat_repr, val, discr, ix)
adt::trans_field_ptr(bcx, &*pat_repr, val, discr, ix)
}).collect::<Vec<_>>();
compile_submatch(
bcx,
@ -1587,7 +1588,7 @@ fn compile_submatch_continue<'a, 'b>(
_ => ccx.sess().bug("non-tuple type in tuple pattern")
};
let tup_vals = Vec::from_fn(n_tup_elts, |i| {
adt::trans_field_ptr(bcx, tup_repr, val, 0, i)
adt::trans_field_ptr(bcx, &*tup_repr, val, 0, i)
});
compile_submatch(bcx,
enter_tup(bcx,
@ -1616,7 +1617,7 @@ fn compile_submatch_continue<'a, 'b>(
let struct_repr = adt::represent_type(bcx.ccx(), struct_ty);
let llstructvals = Vec::from_fn(struct_element_count, |i| {
adt::trans_field_ptr(bcx, struct_repr, val, 0, i)
adt::trans_field_ptr(bcx, &*struct_repr, val, 0, i)
});
compile_submatch(bcx,
enter_tuple_struct(bcx, dm, m, col, val,
@ -1652,8 +1653,8 @@ fn compile_submatch_continue<'a, 'b>(
debug!("test_val={}", bcx.val_to_str(test_val));
if opts.len() > 0u {
match *opts.get(0) {
var(_, repr) => {
let (the_kind, val_opt) = adt::trans_switch(bcx, repr, val);
var(_, ref repr) => {
let (the_kind, val_opt) = adt::trans_switch(bcx, &**repr, val);
kind = the_kind;
for &tval in val_opt.iter() { test_val = tval; }
}
@ -1799,9 +1800,9 @@ fn compile_submatch_continue<'a, 'b>(
let mut size = 0u;
let mut unpacked = Vec::new();
match *opt {
var(disr_val, repr) => {
var(disr_val, ref repr) => {
let ExtractedBlock {vals: argvals, bcx: new_bcx} =
extract_variant_args(opt_cx, repr, disr_val, val);
extract_variant_args(opt_cx, &**repr, disr_val, val);
size = argvals.len();
unpacked = argvals;
opt_cx = new_bcx;
@ -2219,7 +2220,7 @@ fn bind_irrefutable_pat<'a>(
enum_id,
var_id);
let args = extract_variant_args(bcx,
repr,
&*repr,
vinfo.disr_val,
val);
for sub_pat in sub_pats.iter() {
@ -2240,7 +2241,7 @@ fn bind_irrefutable_pat<'a>(
// This is the tuple struct case.
let repr = adt::represent_node(bcx, pat.id);
for (i, elem) in elems.iter().enumerate() {
let fldptr = adt::trans_field_ptr(bcx, repr,
let fldptr = adt::trans_field_ptr(bcx, &*repr,
val, 0, i);
bcx = bind_irrefutable_pat(bcx, *elem,
fldptr, binding_mode,
@ -2263,7 +2264,7 @@ fn bind_irrefutable_pat<'a>(
expr::with_field_tys(tcx, pat_ty, Some(pat.id), |discr, field_tys| {
for f in fields.iter() {
let ix = ty::field_idx_strict(tcx, f.ident.name, field_tys);
let fldptr = adt::trans_field_ptr(bcx, pat_repr, val,
let fldptr = adt::trans_field_ptr(bcx, &*pat_repr, val,
discr, ix);
bcx = bind_irrefutable_pat(bcx, f.pat, fldptr,
binding_mode, cleanup_scope);
@ -2273,7 +2274,7 @@ fn bind_irrefutable_pat<'a>(
ast::PatTup(ref elems) => {
let repr = adt::represent_node(bcx, pat.id);
for (i, elem) in elems.iter().enumerate() {
let fldptr = adt::trans_field_ptr(bcx, repr, val, 0, i);
let fldptr = adt::trans_field_ptr(bcx, &*repr, val, 0, i);
bcx = bind_irrefutable_pat(bcx, *elem, fldptr,
binding_mode, cleanup_scope);
}

14
src/librustc/middle/trans/adt.rs
View File

@ -45,8 +45,8 @@
use std::container::Map;
use libc::c_ulonglong;
use std::option::{Option, Some, None};
use std::num::{Bitwise};
use std::rc::Rc;
use lib::llvm::{ValueRef, True, IntEQ, IntNE};
use middle::trans::_match;
@ -115,22 +115,22 @@ pub struct Struct {
* these, for places in trans where the `ty::t` isn't directly
* available.
*/
pub fn represent_node(bcx: &Block, node: ast::NodeId) -> @Repr {
pub fn represent_node(bcx: &Block, node: ast::NodeId) -> Rc<Repr> {
represent_type(bcx.ccx(), node_id_type(bcx, node))
}
/// Decides how to represent a given type.
pub fn represent_type(cx: &CrateContext, t: ty::t) -> @Repr {
pub fn represent_type(cx: &CrateContext, t: ty::t) -> Rc<Repr> {
debug!("Representing: {}", ty_to_str(cx.tcx(), t));
match cx.adt_reprs.borrow().find(&t) {
Some(repr) => return *repr,
Some(repr) => return repr.clone(),
None => {}
}
let repr = @represent_type_uncached(cx, t);
let repr = Rc::new(represent_type_uncached(cx, t));
debug!("Represented as: {:?}", repr)
cx.adt_reprs.borrow_mut().insert(t, repr);
return repr;
cx.adt_reprs.borrow_mut().insert(t, repr.clone());
repr
}
fn represent_type_uncached(cx: &CrateContext, t: ty::t) -> Repr {

16
src/librustc/middle/trans/base.rs
View File

@ -660,7 +660,7 @@ pub fn iter_structural_ty<'r,
let repr = adt::represent_type(cx.ccx(), t);
expr::with_field_tys(cx.tcx(), t, None, |discr, field_tys| {
for (i, field_ty) in field_tys.iter().enumerate() {
let llfld_a = adt::trans_field_ptr(cx, repr, av, discr, i);
let llfld_a = adt::trans_field_ptr(cx, &*repr, av, discr, i);
cx = f(cx, llfld_a, field_ty.mt.ty);
}
})
@ -678,7 +678,7 @@ pub fn iter_structural_ty<'r,
ty::ty_tup(ref args) => {
let repr = adt::represent_type(cx.ccx(), t);
for (i, arg) in args.iter().enumerate() {
let llfld_a = adt::trans_field_ptr(cx, repr, av, 0, i);
let llfld_a = adt::trans_field_ptr(cx, &*repr, av, 0, i);
cx = f(cx, llfld_a, *arg);
}
}
@ -693,9 +693,9 @@ pub fn iter_structural_ty<'r,
// NB: we must hit the discriminant first so that structural
// comparison know not to proceed when the discriminants differ.
match adt::trans_switch(cx, repr, av) {
match adt::trans_switch(cx, &*repr, av) {
(_match::single, None) => {
cx = iter_variant(cx, repr, av, &**variants.get(0),
cx = iter_variant(cx, &*repr, av, &**variants.get(0),
substs.tps.as_slice(), f);
}
(_match::switch, Some(lldiscrim_a)) => {
@ -710,7 +710,7 @@ pub fn iter_structural_ty<'r,
let variant_cx =
fcx.new_temp_block("enum-iter-variant-".to_owned() +
variant.disr_val.to_str());
match adt::trans_case(cx, repr, variant.disr_val) {
match adt::trans_case(cx, &*repr, variant.disr_val) {
_match::single_result(r) => {
AddCase(llswitch, r.val, variant_cx.llbb)
}
@ -719,7 +719,7 @@ pub fn iter_structural_ty<'r,
}
let variant_cx =
iter_variant(variant_cx,
repr,
&*repr,
av,
&**variant,
substs.tps.as_slice(),
@ -1512,10 +1512,10 @@ fn trans_enum_variant_or_tuple_like_struct(ccx: &CrateContext,
if !type_is_zero_size(fcx.ccx, result_ty) {
let repr = adt::represent_type(ccx, result_ty);
adt::trans_start_init(bcx, repr, fcx.llretptr.get().unwrap(), disr);
adt::trans_start_init(bcx, &*repr, fcx.llretptr.get().unwrap(), disr);
for (i, arg_datum) in arg_datums.move_iter().enumerate() {
let lldestptr = adt::trans_field_ptr(bcx,
repr,
&*repr,
fcx.llretptr.get().unwrap(),
disr,
i);

18
src/librustc/middle/trans/consts.rs
View File

@ -130,7 +130,7 @@ fn const_deref_ptr(cx: &CrateContext, v: ValueRef) -> ValueRef {
fn const_deref_newtype(cx: &CrateContext, v: ValueRef, t: ty::t)
-> ValueRef {
let repr = adt::represent_type(cx, t);
adt::const_get_field(cx, repr, v, 0, 0)
adt::const_get_field(cx, &*repr, v, 0, 0)
}
fn const_deref(cx: &CrateContext, v: ValueRef, t: ty::t, explicit: bool)
@ -418,7 +418,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
let (bv, inlineable) = const_expr(cx, base, is_local);
expr::with_field_tys(cx.tcx(), bt, None, |discr, field_tys| {
let ix = ty::field_idx_strict(cx.tcx(), field.name, field_tys);
(adt::const_get_field(cx, brepr, bv, discr, ix), inlineable)
(adt::const_get_field(cx, &*brepr, bv, discr, ix), inlineable)
})
}
@ -491,7 +491,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
(expr::cast_enum, expr::cast_integral) |
(expr::cast_enum, expr::cast_float) => {
let repr = adt::represent_type(cx, basety);
let discr = adt::const_get_discrim(cx, repr, v);
let discr = adt::const_get_discrim(cx, &*repr, v);
let iv = C_integral(cx.int_type, discr, false);
let ety_cast = expr::cast_type_kind(ety);
match ety_cast {
@ -524,7 +524,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
let ety = ty::expr_ty(cx.tcx(), e);
let repr = adt::represent_type(cx, ety);
let (vals, inlineable) = map_list(es.as_slice());
(adt::trans_const(cx, repr, 0, vals.as_slice()), inlineable)
(adt::trans_const(cx, &*repr, 0, vals.as_slice()), inlineable)
}
ast::ExprStruct(_, ref fs, ref base_opt) => {
let ety = ty::expr_ty(cx.tcx(), e);
@ -544,7 +544,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
None => {
match base_val {
Some((bv, inlineable)) => {
(adt::const_get_field(cx, repr, bv, discr, ix),
(adt::const_get_field(cx, &*repr, bv, discr, ix),
inlineable)
}
None => cx.sess().span_bug(e.span, "missing struct field")
@ -552,7 +552,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
}
}
}));
(adt::trans_const(cx, repr, discr, cs),
(adt::trans_const(cx, &*repr, discr, cs),
inlineable.iter().fold(true, |a, &b| a && b))
})
}
@ -632,7 +632,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
let vinfo = ty::enum_variant_with_id(cx.tcx(),
enum_did,
variant_did);
(adt::trans_const(cx, repr, vinfo.disr_val, []), true)
(adt::trans_const(cx, &*repr, vinfo.disr_val, []), true)
}
Some(ast::DefStruct(_)) => {
let ety = ty::expr_ty(cx.tcx(), e);
@ -651,7 +651,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
let ety = ty::expr_ty(cx.tcx(), e);
let repr = adt::represent_type(cx, ety);
let (arg_vals, inlineable) = map_list(args.as_slice());
(adt::trans_const(cx, repr, 0, arg_vals.as_slice()),
(adt::trans_const(cx, &*repr, 0, arg_vals.as_slice()),
inlineable)
}
Some(ast::DefVariant(enum_did, variant_did, _)) => {
@ -662,7 +662,7 @@ fn const_expr_unadjusted(cx: &CrateContext, e: &ast::Expr,
variant_did);
let (arg_vals, inlineable) = map_list(args.as_slice());
(adt::trans_const(cx,
repr,
&*repr,
vinfo.disr_val,
arg_vals.as_slice()), inlineable)
}

3
src/librustc/middle/trans/context.rs
View File

@ -31,6 +31,7 @@ use util::nodemap::{NodeMap, NodeSet, DefIdMap};
use std::cell::{Cell, RefCell};
use std::c_str::ToCStr;
use std::ptr;
use std::rc::Rc;
use collections::{HashMap, HashSet};
use syntax::ast;
use syntax::parse::token::InternedString;
@ -92,7 +93,7 @@ pub struct CrateContext {
pub lltypes: RefCell<HashMap<ty::t, Type>>,
pub llsizingtypes: RefCell<HashMap<ty::t, Type>>,
pub adt_reprs: RefCell<HashMap<ty::t, @adt::Repr>>,
pub adt_reprs: RefCell<HashMap<ty::t, Rc<adt::Repr>>>,
pub symbol_hasher: RefCell<Sha256>,
pub type_hashcodes: RefCell<HashMap<ty::t, ~str>>,
pub all_llvm_symbols: RefCell<HashSet<~str>>,

4
src/librustc/middle/trans/debuginfo.rs
View File

@ -1389,7 +1389,7 @@ fn prepare_tuple_metadata(cx: &CrateContext,
}
struct GeneralMemberDescriptionFactory {
type_rep: @adt::Repr,
type_rep: Rc<adt::Repr>,
variants: Rc<Vec<Rc<ty::VariantInfo>>>,
discriminant_type_metadata: ValueRef,
containing_scope: DIScope,
@ -1662,7 +1662,7 @@ fn prepare_enum_metadata(cx: &CrateContext,
llvm_type: enum_llvm_type,
file_metadata: file_metadata,
member_description_factory: GeneralMD(GeneralMemberDescriptionFactory {
type_rep: type_rep,
type_rep: type_rep.clone(),
variants: variants,
discriminant_type_metadata: discriminant_type_metadata,
containing_scope: containing_scope,

16
src/librustc/middle/trans/expr.rs
View File

@ -443,7 +443,7 @@ fn trans_rec_field<'a>(bcx: &'a Block<'a>,
let ix = ty::field_idx_strict(bcx.tcx(), field.name, field_tys);
let d = base_datum.get_element(
field_tys[ix].mt.ty,
|srcval| adt::trans_field_ptr(bcx, repr, srcval, discr, ix));
|srcval| adt::trans_field_ptr(bcx, &*repr, srcval, discr, ix));
DatumBlock { datum: d.to_expr_datum(), bcx: bcx }
})
}
@ -679,7 +679,7 @@ fn trans_rvalue_dps_unadjusted<'a>(bcx: &'a Block<'a>,
let repr = adt::represent_type(bcx.ccx(), expr_ty(bcx, expr));
let numbered_fields: Vec<(uint, @ast::Expr)> =
args.iter().enumerate().map(|(i, arg)| (i, *arg)).collect();
trans_adt(bcx, repr, 0, numbered_fields.as_slice(), None, dest)
trans_adt(bcx, &*repr, 0, numbered_fields.as_slice(), None, dest)
}
ast::ExprLit(lit) => {
match lit.node {
@ -797,7 +797,7 @@ fn trans_def_dps_unadjusted<'a>(
// Nullary variant.
let ty = expr_ty(bcx, ref_expr);
let repr = adt::represent_type(bcx.ccx(), ty);
adt::trans_start_init(bcx, repr, lldest,
adt::trans_start_init(bcx, &*repr, lldest,
variant_info.disr_val);
return bcx;
}
@ -807,7 +807,7 @@ fn trans_def_dps_unadjusted<'a>(
match ty::get(ty).sty {
ty::ty_struct(did, _) if ty::has_dtor(bcx.tcx(), did) => {
let repr = adt::represent_type(bcx.ccx(), ty);
adt::trans_start_init(bcx, repr, lldest, 0);
adt::trans_start_init(bcx, &*repr, lldest, 0);
}
_ => {}
}
@ -1004,7 +1004,7 @@ fn trans_rec_or_struct<'a>(
};
let repr = adt::represent_type(bcx.ccx(), ty);
trans_adt(bcx, repr, discr, numbered_fields.as_slice(), optbase, dest)
trans_adt(bcx, &*repr, discr, numbered_fields.as_slice(), optbase, dest)
})
}
@ -1239,8 +1239,8 @@ fn trans_gc<'a>(mut bcx: &'a Block<'a>,
SaveIn(addr) => {
let expr_ty = expr_ty(bcx, expr);
let repr = adt::represent_type(bcx.ccx(), expr_ty);
adt::trans_start_init(bcx, repr, addr, 0);
let field_dest = adt::trans_field_ptr(bcx, repr, addr, 0, 0);
adt::trans_start_init(bcx, &*repr, addr, 0);
let field_dest = adt::trans_field_ptr(bcx, &*repr, addr, 0, 0);
contents_datum.store_to(bcx, field_dest)
}
}
@ -1580,7 +1580,7 @@ fn trans_imm_cast<'a>(bcx: &'a Block<'a>,
bcx, datum.to_lvalue_datum(bcx, "trans_imm_cast", expr.id));
let llexpr_ptr = datum.to_llref();
let lldiscrim_a =
adt::trans_get_discr(bcx, repr, llexpr_ptr, Some(Type::i64(ccx)));
adt::trans_get_discr(bcx, &*repr, llexpr_ptr, Some(Type::i64(ccx)));
match k_out {
cast_integral => int_cast(bcx, ll_t_out,
val_ty(lldiscrim_a),

4
src/librustc/middle/trans/glue.rs
View File

@ -224,7 +224,7 @@ fn trans_struct_drop_flag<'a>(bcx: &'a Block<'a>,
substs: &ty::substs)
-> &'a Block<'a> {
let repr = adt::represent_type(bcx.ccx(), t);
let drop_flag = adt::trans_drop_flag_ptr(bcx, repr, v0);
let drop_flag = adt::trans_drop_flag_ptr(bcx, &*repr, v0);
with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag)), |cx| {
trans_struct_drop(cx, t, v0, dtor_did, class_did, substs)
})
@ -265,7 +265,7 @@ fn trans_struct_drop<'a>(bcx: &'a Block<'a>,
// this scope.
let field_tys = ty::struct_fields(bcx.tcx(), class_did, substs);
for (i, fld) in field_tys.iter().enumerate() {
let llfld_a = adt::trans_field_ptr(bcx, repr, v0, 0, i);
let llfld_a = adt::trans_field_ptr(bcx, &*repr, v0, 0, i);
bcx.fcx.schedule_drop_mem(cleanup::CustomScope(field_scope),
llfld_a,
fld.mt.ty);

4
src/librustc/middle/trans/reflect.rs
View File

@ -320,7 +320,7 @@ impl<'a, 'b> Reflector<'a, 'b> {
};
let bcx = fcx.entry_bcx.borrow().clone().unwrap();
let arg = BitCast(bcx, arg, llptrty);
let ret = adt::trans_get_discr(bcx, repr, arg, Some(Type::i64(ccx)));
let ret = adt::trans_get_discr(bcx, &*repr, arg, Some(Type::i64(ccx)));
Store(bcx, ret, fcx.llretptr.get().unwrap());
match fcx.llreturn.get() {
Some(llreturn) => Br(bcx, llreturn),
@ -345,7 +345,7 @@ impl<'a, 'b> Reflector<'a, 'b> {
for (j, a) in v.args.iter().enumerate() {
let bcx = this.bcx;
let null = C_null(llptrty);
let ptr = adt::trans_field_ptr(bcx, repr, null, v.disr_val, j);
let ptr = adt::trans_field_ptr(bcx, &*repr, null, v.disr_val, j);
let offset = p2i(ccx, ptr);
let field_args = [this.c_uint(j),
offset,

12
src/librustc/middle/trans/type_of.rs
View File

@ -142,7 +142,7 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
ty::ty_tup(..) | ty::ty_enum(..) => {
let repr = adt::represent_type(cx, t);
adt::sizing_type_of(cx, repr)
adt::sizing_type_of(cx, &*repr)
}
ty::ty_struct(..) => {
@ -152,7 +152,7 @@ pub fn sizing_type_of(cx: &CrateContext, t: ty::t) -> Type {
Type::vector(&type_of(cx, et), n as u64)
} else {
let repr = adt::represent_type(cx, t);
adt::sizing_type_of(cx, repr)
adt::sizing_type_of(cx, &*repr)
}
}
@ -213,7 +213,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
// of the enum's variants refers to the enum itself.
let repr = adt::represent_type(cx, t);
let name = llvm_type_name(cx, an_enum, did, substs.tps.as_slice());
adt::incomplete_type_of(cx, repr, name)
adt::incomplete_type_of(cx, &*repr, name)
}
ty::ty_box(typ) => {
Type::at_box(cx, type_of(cx, typ)).ptr_to()
@ -259,7 +259,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
ty::ty_trait(..) => Type::opaque_trait(cx),
ty::ty_tup(..) => {
let repr = adt::represent_type(cx, t);
adt::type_of(cx, repr)
adt::type_of(cx, &*repr)
}
ty::ty_struct(did, ref substs) => {
if ty::type_is_simd(cx.tcx(), t) {
@ -275,7 +275,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
a_struct,
did,
substs.tps.as_slice());
adt::incomplete_type_of(cx, repr, name)
adt::incomplete_type_of(cx, &*repr, name)
}
}
@ -297,7 +297,7 @@ pub fn type_of(cx: &CrateContext, t: ty::t) -> Type {
match ty::get(t).sty {
ty::ty_enum(..) | ty::ty_struct(..) if !ty::type_is_simd(cx.tcx(), t) => {
let repr = adt::represent_type(cx, t);
adt::finish_type_of(cx, repr, &mut llty);
adt::finish_type_of(cx, &*repr, &mut llty);
}
_ => ()
}