user0/rust
1
0
Fork 0
Code Issues Pull requests Projects Releases Packages Wiki Activity Actions

Memoize trans::adt::represent_type

Browse source
This commit is contained in:
Jed Davis 2013-02-25 01:49:21 -08:00
parent a8237a46f1
commit a9026c7f19
9 changed files with 58 additions and 48 deletions
Download patch file Download diff file Expand all files Collapse all files

22
src/librustc/middle/trans/_match.rs
View file

@ -192,7 +192,7 @@ pub enum Lit {
// range)
pub enum Opt {
lit(Lit),
var(/* disr val */int, adt::Repr),
var(/* disr val */int, @adt::Repr),
range(@ast::expr, @ast::expr),
vec_len_eq(uint),
vec_len_ge(uint)
@ -268,7 +268,7 @@ pub fn trans_opt(bcx: block, o: &Opt) -> opt_result {
let llval = consts::get_const_val(bcx.ccx(), lit_id);
return single_result(rslt(bcx, llval));
}
var(disr_val, ref repr) => {
var(disr_val, repr) => {
return adt::trans_case(bcx, repr, disr_val);
}
range(l1, l2) => {
@ -1274,7 +1274,7 @@ pub fn compile_submatch(bcx: block,
do expr::with_field_tys(tcx, pat_ty, None) |discr, field_tys| {
let rec_vals = rec_fields.map(|field_name| {
let ix = ty::field_idx_strict(tcx, *field_name, field_tys);
adt::trans_GEP(bcx, &pat_repr, val, discr, ix)
adt::trans_GEP(bcx, pat_repr, val, discr, ix)
});
compile_submatch(
bcx,
@ -1293,7 +1293,7 @@ pub fn compile_submatch(bcx: block,
_ => ccx.sess.bug(~"non-tuple type in tuple pattern")
};
let tup_vals = do vec::from_fn(n_tup_elts) |i| {
adt::trans_GEP(bcx, &tup_repr, val, 0, i)
adt::trans_GEP(bcx, tup_repr, val, 0, i)
};
compile_submatch(bcx, enter_tup(bcx, dm, m, col, val, n_tup_elts),
vec::append(tup_vals, vals_left), chk);
@ -1315,7 +1315,7 @@ pub fn compile_submatch(bcx: block,
let struct_repr = adt::represent_type(bcx.ccx(), struct_ty);
let llstructvals = do vec::from_fn(struct_element_count) |i| {
adt::trans_GEP(bcx, &struct_repr, val, 0, i)
adt::trans_GEP(bcx, struct_repr, val, 0, i)
};
compile_submatch(bcx,
enter_tuple_struct(bcx, dm, m, col, val,
@ -1359,7 +1359,7 @@ pub fn compile_submatch(bcx: block,
let mut test_val = val;
if opts.len() > 0u {
match opts[0] {
var(_, ref repr) => {
var(_, repr) => {
let (the_kind, val_opt) = adt::trans_switch(bcx, repr, val);
kind = the_kind;
for val_opt.each |&tval| { test_val = tval; }
@ -1511,7 +1511,7 @@ pub fn compile_submatch(bcx: block,
let mut size = 0u;
let mut unpacked = ~[];
match *opt {
var(disr_val, ref repr) => {
var(disr_val, repr) => {
let ExtractedBlock {vals: argvals, bcx: new_bcx} =
extract_variant_args(opt_cx, repr, disr_val, val);
size = argvals.len();
@ -1731,7 +1731,7 @@ pub fn bind_irrefutable_pat(bcx: block,
enum_id,
var_id);
let args = extract_variant_args(bcx,
&repr,
repr,
vinfo.disr_val,
val);
for sub_pats.each |sub_pat| {
@ -1753,7 +1753,7 @@ pub fn bind_irrefutable_pat(bcx: block,
// This is the tuple struct case.
let repr = adt::represent_node(bcx, pat.id);
for vec::eachi(elems) |i, elem| {
let fldptr = adt::trans_GEP(bcx, &repr,
let fldptr = adt::trans_GEP(bcx, repr,
val, 0, i);
bcx = bind_irrefutable_pat(bcx,
*elem,
@ -1776,7 +1776,7 @@ pub fn bind_irrefutable_pat(bcx: block,
do expr::with_field_tys(tcx, pat_ty, None) |discr, field_tys| {
for vec::each(fields) |f| {
let ix = ty::field_idx_strict(tcx, f.ident, field_tys);
let fldptr = adt::trans_GEP(bcx, &pat_repr, val,
let fldptr = adt::trans_GEP(bcx, pat_repr, val,
discr, ix);
bcx = bind_irrefutable_pat(bcx,
f.pat,
@ -1789,7 +1789,7 @@ pub fn bind_irrefutable_pat(bcx: block,
ast::pat_tup(elems) => {
let repr = adt::represent_node(bcx, pat.id);
for vec::eachi(elems) |i, elem| {
let fldptr = adt::trans_GEP(bcx, &repr, val, 0, i);
let fldptr = adt::trans_GEP(bcx, repr, val, 0, i);
bcx = bind_irrefutable_pat(bcx,
*elem,
fldptr,

17
src/librustc/middle/trans/adt.rs
View file

@ -8,6 +8,7 @@
// option. This file may not be copied, modified, or distributed
// except according to those terms.
use core::container::Map;
use core::libc::c_ulonglong;
use core::option::{Option, Some, None};
use core::vec;
@ -43,15 +44,17 @@ struct Struct {
}
pub fn represent_node(bcx: block, node: ast::node_id)
-> Repr {
pub fn represent_node(bcx: block, node: ast::node_id) -> @Repr {
represent_type(bcx.ccx(), node_id_type(bcx, node))
}
pub fn represent_type(cx: @CrateContext, t: ty::t) -> Repr {
pub fn represent_type(cx: @CrateContext, t: ty::t) -> @Repr {
debug!("Representing: %s", ty_to_str(cx.tcx, t));
// XXX: cache this
match ty::get(t).sty {
match cx.adt_reprs.find(&t) {
Some(repr) => return *repr,
None => { }
}
let repr = @match ty::get(t).sty {
ty::ty_tup(ref elems) => {
Univariant(mk_struct(cx, *elems), NoDtor)
}
@ -97,7 +100,9 @@ pub fn represent_type(cx: @CrateContext, t: ty::t) -> Repr {
}
}
_ => cx.sess.bug(~"adt::represent_type called on non-ADT type")
}
};
cx.adt_reprs.insert(t, repr);
return repr;
}
fn mk_struct(cx: @CrateContext, tys: &[ty::t]) -> Struct {

20
src/librustc/middle/trans/base.rs
View file

@ -67,6 +67,7 @@ use util::ppaux::{ty_to_str, ty_to_short_str};
use util::ppaux;
use core::hash;
use core::hashmap::linear::LinearMap;
use core::int;
use core::io;
use core::libc::{c_uint, c_ulonglong};
@ -641,7 +642,7 @@ pub fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
let repr = adt::represent_type(cx.ccx(), t);
do expr::with_field_tys(cx.tcx(), t, None) |discr, field_tys| {
for vec::eachi(field_tys) |i, field_ty| {
let llfld_a = adt::trans_GEP(cx, &repr, av, discr, i);
let llfld_a = adt::trans_GEP(cx, repr, av, discr, i);
cx = f(cx, llfld_a, field_ty.mt.ty);
}
}
@ -654,7 +655,7 @@ pub fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
ty::ty_tup(args) => {
let repr = adt::represent_type(cx.ccx(), t);
for vec::eachi(args) |i, arg| {
let llfld_a = adt::trans_GEP(cx, &repr, av, 0, i);
let llfld_a = adt::trans_GEP(cx, repr, av, 0, i);
cx = f(cx, llfld_a, *arg);
}
}
@ -668,9 +669,9 @@ pub fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
// 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[0],
cx = iter_variant(cx, repr, av, variants[0],
substs.tps, f);
}
(_match::switch, Some(lldiscrim_a)) => {
@ -686,9 +687,9 @@ pub fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
sub_block(cx, ~"enum-iter-variant-" +
int::to_str(variant.disr_val));
let variant_cx =
iter_variant(variant_cx, &repr, av, *variant,
iter_variant(variant_cx, repr, av, *variant,
substs.tps, f);
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)
}
@ -1863,9 +1864,9 @@ pub fn trans_enum_variant(ccx: @CrateContext,
ty::node_id_to_type(ccx.tcx, enum_id));
let repr = adt::represent_type(ccx, enum_ty);
adt::trans_set_discr(bcx, &repr, fcx.llretptr, disr);
adt::trans_set_discr(bcx, repr, fcx.llretptr, disr);
for vec::eachi(args) |i, va| {
let lldestptr = adt::trans_GEP(bcx, &repr, fcx.llretptr, disr, i);
let lldestptr = adt::trans_GEP(bcx, repr, fcx.llretptr, disr, i);
// If this argument to this function is a enum, it'll have come in to
// this function as an opaque blob due to the way that type_of()
@ -1935,7 +1936,7 @@ pub fn trans_tuple_struct(ccx: @CrateContext,
let repr = adt::represent_type(ccx, tup_ty);
for fields.eachi |i, field| {
let lldestptr = adt::trans_GEP(bcx, &repr, fcx.llretptr, 0, i);
let lldestptr = adt::trans_GEP(bcx, repr, fcx.llretptr, 0, i);
let llarg = match fcx.llargs.get(&field.node.id) {
local_mem(x) => x,
_ => {
@ -3050,6 +3051,7 @@ pub fn trans_crate(sess: session::Session,
module_data: HashMap(),
lltypes: ty::new_ty_hash(),
llsizingtypes: ty::new_ty_hash(),
adt_reprs: @mut LinearMap::new(),
names: new_namegen(sess.parse_sess.interner),
next_addrspace: new_addrspace_gen(),
symbol_hasher: symbol_hasher,

3
src/librustc/middle/trans/common.rs
View file

@ -26,6 +26,7 @@ use lib;
use metadata::common::LinkMeta;
use middle::astencode;
use middle::resolve;
use middle::trans::adt;
use middle::trans::base;
use middle::trans::build;
use middle::trans::callee;
@ -44,6 +45,7 @@ use util::ppaux::{expr_repr, ty_to_str};
use core::cast;
use core::hash;
use core::hashmap::linear::LinearMap;
use core::libc::{c_uint, c_longlong, c_ulonglong};
use core::ptr;
use core::str;
@ -203,6 +205,7 @@ pub struct CrateContext {
module_data: HashMap<~str, ValueRef>,
lltypes: HashMap<ty::t, TypeRef>,
llsizingtypes: HashMap<ty::t, TypeRef>,
adt_reprs: @mut LinearMap<ty::t, @adt::Repr>,
names: namegen,
next_addrspace: addrspace_gen,
symbol_hasher: @hash::State,

16
src/librustc/middle/trans/consts.rs
View file

@ -245,7 +245,7 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
let (bt, bv) = const_autoderef(cx, bt, bv);
do expr::with_field_tys(cx.tcx, bt, None) |discr, field_tys| {
let ix = ty::field_idx_strict(cx.tcx, field, field_tys);
adt::const_get_element(cx, &brepr, bv, discr, ix)
adt::const_get_element(cx, brepr, bv, discr, ix)
}
}
@ -326,7 +326,7 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
(expr::cast_enum, expr::cast_integral) |
(expr::cast_enum, expr::cast_float) => {
let repr = adt::represent_type(cx, basety);
let iv = C_int(cx, adt::const_get_discrim(cx, &repr, v));
let iv = C_int(cx, adt::const_get_discrim(cx, repr, v));
let ety_cast = expr::cast_type_kind(ety);
match ety_cast {
expr::cast_integral => {
@ -356,12 +356,12 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
ast::expr_tup(es) => {
let ety = ty::expr_ty(cx.tcx, e);
let repr = adt::represent_type(cx, ety);
adt::trans_const(cx, &repr, 0, es.map(|e| const_expr(cx, *e)))
adt::trans_const(cx, repr, 0, es.map(|e| const_expr(cx, *e)))
}
ast::expr_rec(ref fs, None) => {
let ety = ty::expr_ty(cx.tcx, e);
let repr = adt::represent_type(cx, ety);
adt::trans_const(cx, &repr, 0,
adt::trans_const(cx, repr, 0,
fs.map(|f| const_expr(cx, f.node.expr)))
}
ast::expr_struct(_, ref fs, None) => {
@ -378,7 +378,7 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
}
}
});
adt::trans_const(cx, &repr, discr, cs)
adt::trans_const(cx, repr, discr, cs)
}
}
ast::expr_vec(es, ast::m_imm) => {
@ -442,7 +442,7 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
let vinfo = ty::enum_variant_with_id(cx.tcx,
enum_did,
variant_did);
adt::trans_const(cx, &repr, vinfo.disr_val, [])
adt::trans_const(cx, repr, vinfo.disr_val, [])
}
Some(ast::def_struct(_)) => {
let ety = ty::expr_ty(cx.tcx, e);
@ -460,7 +460,7 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
Some(ast::def_struct(_)) => {
let ety = ty::expr_ty(cx.tcx, e);
let repr = adt::represent_type(cx, ety);
adt::trans_const(cx, &repr, 0,
adt::trans_const(cx, repr, 0,
args.map(|a| const_expr(cx, *a)))
}
Some(ast::def_variant(enum_did, variant_did)) => {
@ -469,7 +469,7 @@ fn const_expr_unchecked(cx: @CrateContext, e: @ast::expr) -> ValueRef {
let vinfo = ty::enum_variant_with_id(cx.tcx,
enum_did,
variant_did);
adt::trans_const(cx, &repr, vinfo.disr_val,
adt::trans_const(cx, repr, vinfo.disr_val,
args.map(|a| const_expr(cx, *a)))
}
_ => cx.sess.span_bug(e.span, ~"expected a struct or \

8
src/librustc/middle/trans/datum.rs
View file

@ -679,7 +679,7 @@ pub impl Datum {
}
let repr = adt::represent_type(ccx, self.ty);
assert adt::is_newtypeish(&repr);
assert adt::is_newtypeish(repr);
let ty = ty::subst(ccx.tcx, substs, variants[0].args[0]);
return match self.mode {
ByRef => {
@ -687,7 +687,7 @@ pub impl Datum {
// rather than a ptr to the enum type.
(
Some(Datum {
val: adt::trans_GEP(bcx, &repr, self.val,
val: adt::trans_GEP(bcx, repr, self.val,
0, 0),
ty: ty,
mode: ByRef,
@ -719,7 +719,7 @@ pub impl Datum {
}
let repr = adt::represent_type(ccx, self.ty);
assert adt::is_newtypeish(&repr);
assert adt::is_newtypeish(repr);
let ty = fields[0].mt.ty;
return match self.mode {
ByRef => {
@ -729,7 +729,7 @@ pub impl Datum {
// destructors.
(
Some(Datum {
val: adt::trans_GEP(bcx, &repr, self.val,
val: adt::trans_GEP(bcx, repr, self.val,
0, 0),
ty: ty,
mode: ByRef,

10
src/librustc/middle/trans/expr.rs
View file

@ -604,7 +604,7 @@ fn trans_rvalue_dps_unadjusted(bcx: block, expr: @ast::expr,
}
ast::expr_tup(ref args) => {
let repr = adt::represent_type(bcx.ccx(), expr_ty(bcx, expr));
return trans_adt(bcx, &repr, 0, args.mapi(|i, arg| (i, *arg)),
return trans_adt(bcx, repr, 0, args.mapi(|i, arg| (i, *arg)),
None, dest);
}
ast::expr_lit(@codemap::spanned {node: ast::lit_str(s), _}) => {
@ -726,7 +726,7 @@ fn trans_def_dps_unadjusted(bcx: block, ref_expr: @ast::expr,
// Nullary variant.
let ty = expr_ty(bcx, ref_expr);
let repr = adt::represent_type(ccx, ty);
adt::trans_set_discr(bcx, &repr, lldest,
adt::trans_set_discr(bcx, repr, lldest,
variant_info.disr_val);
return bcx;
}
@ -891,7 +891,7 @@ fn trans_lvalue_unadjusted(bcx: block, expr: @ast::expr) -> DatumBlock {
datum: do base_datum.get_element(bcx,
field_tys[ix].mt.ty,
ZeroMem) |srcval| {
adt::trans_GEP(bcx, &repr, srcval, discr, ix)
adt::trans_GEP(bcx, repr, srcval, discr, ix)
},
bcx: bcx
}
@ -1192,7 +1192,7 @@ fn trans_rec_or_struct(bcx: block,
};
let repr = adt::represent_type(bcx.ccx(), ty);
trans_adt(bcx, &repr, discr, numbered_fields, optbase, dest)
trans_adt(bcx, repr, discr, numbered_fields, optbase, dest)
}
}
@ -1645,7 +1645,7 @@ fn trans_imm_cast(bcx: block, expr: @ast::expr,
(cast_enum, cast_float) => {
let bcx = bcx;
let repr = adt::represent_type(ccx, t_in);
let lldiscrim_a = adt::trans_cast_to_int(bcx, &repr, llexpr);
let lldiscrim_a = adt::trans_cast_to_int(bcx, repr, llexpr);
match k_out {
cast_integral => int_cast(bcx, ll_t_out,
val_ty(lldiscrim_a),

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

@ -469,7 +469,7 @@ pub fn trans_struct_drop(bcx: block,
take_ref: bool)
-> block {
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);
do with_cond(bcx, IsNotNull(bcx, Load(bcx, drop_flag))) |cx| {
let mut bcx = cx;
@ -507,7 +507,7 @@ pub fn trans_struct_drop(bcx: block,
ty::struct_mutable_fields(bcx.tcx(), class_did,
substs);
for vec::eachi(field_tys) |i, fld| {
let llfld_a = adt::trans_GEP(bcx, &repr, v0, 0, i);
let llfld_a = adt::trans_GEP(bcx, repr, v0, 0, i);
bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
}

6
src/librustc/middle/trans/type_of.rs
View file

@ -147,7 +147,7 @@ pub fn sizing_type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
ty::ty_tup(*) | ty::ty_rec(*) | ty::ty_struct(*)
| ty::ty_enum(*) => {
let repr = adt::represent_type(cx, t);
T_struct(adt::sizing_fields_of(cx, &repr))
T_struct(adt::sizing_fields_of(cx, repr))
}
ty::ty_self | ty::ty_infer(*) | ty::ty_param(*) | ty::ty_err(*) => {
@ -244,7 +244,7 @@ pub fn type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
ty::ty_type => T_ptr(cx.tydesc_type),
ty::ty_tup(*) | ty::ty_rec(*) => {
let repr = adt::represent_type(cx, t);
T_struct(adt::fields_of(cx, &repr))
T_struct(adt::fields_of(cx, repr))
}
ty::ty_opaque_closure_ptr(_) => T_opaque_box_ptr(cx),
ty::ty_struct(did, ref substs) => {
@ -269,7 +269,7 @@ pub fn type_of(cx: @CrateContext, t: ty::t) -> TypeRef {
match ty::get(t).sty {
ty::ty_enum(*) | ty::ty_struct(*) => {
let repr = adt::represent_type(cx, t);
common::set_struct_body(llty, adt::fields_of(cx, &repr));
common::set_struct_body(llty, adt::fields_of(cx, repr));
}
_ => ()
}