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

adt.rs renaming: "field" rather than "element"; set_discr -> start_init.

Browse Source 
This way "field" refers to the abstraction and "element" (as in get_elt,
"get element pointer", etc.) refers to the low-level LLVM operations.
This commit is contained in:
Jed Davis 2013-03-02 16:08:49 -08:00
parent e13111fc5a
commit 1f9bc64bae
7 changed files with 44 additions and 37 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

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

@ -838,7 +838,7 @@ pub fn extract_variant_args(bcx: block,
-> ExtractedBlock {
let _icx = bcx.insn_ctxt("match::extract_variant_args");
let args = do vec::from_fn(adt::num_args(repr, disr_val)) |i| {
adt::trans_GEP(bcx, repr, val, disr_val, i)
adt::trans_field_ptr(bcx, repr, val, disr_val, i)
};
ExtractedBlock { vals: args, bcx: bcx }
@ -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_field_ptr(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_field_ptr(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_field_ptr(bcx, struct_repr, val, 0, i)
};
compile_submatch(bcx,
enter_tuple_struct(bcx, dm, m, col, val,
@ -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_field_ptr(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_field_ptr(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_field_ptr(bcx, repr, val, 0, i);
bcx = bind_irrefutable_pat(bcx,
*elem,
fldptr,

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

@ -301,10 +301,10 @@ pub fn trans_case(bcx: block, r: &Repr, discr: int) -> _match::opt_result {
/**
* Begin initializing a new value of the given case of the given
* representation. The fields should then be initialized with
* `trans_GEP` and stores.
* representation. The fields, if any, should then be initialized via
* `trans_field_ptr`.
*/
pub fn trans_set_discr(bcx: block, r: &Repr, val: ValueRef, discr: int) {
pub fn trans_start_init(bcx: block, r: &Repr, val: ValueRef, discr: int) {
match *r {
Unit(the_discr) => {
assert discr == the_discr;
@ -339,8 +339,8 @@ pub fn num_args(r: &Repr, discr: int) -> uint {
}
/// Access a field, at a point when the value's case is known.
pub fn trans_GEP(bcx: block, r: &Repr, val: ValueRef, discr: int, ix: uint)
-> ValueRef {
pub fn trans_field_ptr(bcx: block, r: &Repr, val: ValueRef, discr: int,
ix: uint) -> ValueRef {
// Note: if this ever needs to generate conditionals (e.g., if we
// decide to do some kind of cdr-coding-like non-unique repr
// someday), it will need to return a possibly-new bcx as well.
@ -354,16 +354,16 @@ pub fn trans_GEP(bcx: block, r: &Repr, val: ValueRef, discr: int, ix: uint)
NonStruct => val,
StructWithDtor | StructWithoutDtor => GEPi(bcx, val, [0, 0])
};
struct_GEP(bcx, st, val, ix, false)
struct_field_ptr(bcx, st, val, ix, false)
}
General(ref cases) => {
struct_GEP(bcx, &cases[discr as uint],
GEPi(bcx, val, [0, 1]), ix, true)
struct_field_ptr(bcx, &cases[discr as uint],
GEPi(bcx, val, [0, 1]), ix, true)
}
}
}
fn struct_GEP(bcx: block, st: &Struct, val: ValueRef, ix: uint,
fn struct_field_ptr(bcx: block, st: &Struct, val: ValueRef, ix: uint,
needs_cast: bool) -> ValueRef {
let ccx = bcx.ccx();
@ -501,10 +501,15 @@ pub fn const_get_discrim(ccx: @CrateContext, r: &Repr, val: ValueRef)
}
}
/// Access a field of a constant value.
pub fn const_get_element(ccx: @CrateContext, r: &Repr, val: ValueRef,
_discr: int, ix: uint) -> ValueRef {
// Not to be confused with common::const_get_elt.
/**
* Extract a field of a constant value, as appropriate for its
* representation.
*
* (Not to be confused with `common::const_get_elt`, which operates on
* raw LLVM-level structs and arrays.)
*/
pub fn const_get_field(ccx: @CrateContext, r: &Repr, val: ValueRef,
_discr: int, ix: uint) -> ValueRef {
match *r {
Unit(*) | CEnum(*) => ccx.sess.bug(~"element access in C-like enum \
const"),

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

@ -630,7 +630,8 @@ pub fn iter_structural_ty(cx: block, av: ValueRef, t: ty::t,
let mut cx = cx;
for variant.args.eachi |i, &arg| {
cx = f(cx, adt::trans_GEP(cx, repr, av, variant.disr_val, i),
cx = f(cx,
adt::trans_field_ptr(cx, repr, av, variant.disr_val, i),
ty::subst_tps(tcx, tps, None, arg));
}
return cx;
@ -642,7 +643,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_field_ptr(cx, repr, av, discr, i);
cx = f(cx, llfld_a, field_ty.mt.ty);
}
}
@ -655,7 +656,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_field_ptr(cx, repr, av, 0, i);
cx = f(cx, llfld_a, *arg);
}
}
@ -1864,9 +1865,10 @@ 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_start_init(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_field_ptr(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()
@ -1936,7 +1938,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_field_ptr(bcx, repr, fcx.llretptr, 0, i);
let llarg = match fcx.llargs.get(&field.node.id) {
local_mem(x) => x,
_ => {

2
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_field(cx, brepr, bv, discr, ix)
}
}

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

@ -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_field_ptr(bcx, repr, self.val,
0, 0),
ty: ty,
mode: ByRef,
@ -729,7 +729,7 @@ pub impl Datum {
// destructors.
(
Some(Datum {
val: adt::trans_GEP(bcx, repr, self.val,
val: adt::trans_field_ptr(bcx, repr, self.val,
0, 0),
ty: ty,
mode: ByRef,

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

@ -726,8 +726,8 @@ 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,
variant_info.disr_val);
adt::trans_start_init(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_field_ptr(bcx, repr, srcval, discr, ix)
},
bcx: bcx
}
@ -1240,9 +1240,9 @@ fn trans_adt(bcx: block, repr: &adt::Repr, discr: int,
SaveIn(pos) => pos
};
let mut temp_cleanups = ~[];
adt::trans_set_discr(bcx, repr, addr, discr);
adt::trans_start_init(bcx, repr, addr, discr);
for fields.each |&(i, e)| {
let dest = adt::trans_GEP(bcx, repr, addr, discr, i);
let dest = adt::trans_field_ptr(bcx, repr, addr, discr, i);
let e_ty = expr_ty(bcx, e);
bcx = trans_into(bcx, e, SaveIn(dest));
add_clean_temp_mem(bcx, dest, e_ty);
@ -1254,9 +1254,9 @@ fn trans_adt(bcx: block, repr: &adt::Repr, discr: int,
let base_datum = unpack_datum!(bcx, trans_to_datum(bcx, base.expr));
for base.fields.each |&(i, t)| {
let datum = do base_datum.get_element(bcx, t, ZeroMem) |srcval| {
adt::trans_GEP(bcx, repr, srcval, discr, i)
adt::trans_field_ptr(bcx, repr, srcval, discr, i)
};
let dest = adt::trans_GEP(bcx, repr, addr, discr, i);
let dest = adt::trans_field_ptr(bcx, repr, addr, discr, i);
bcx = datum.store_to(bcx, base.expr.id, INIT, dest);
}
}

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

@ -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_field_ptr(bcx, repr, v0, 0, i);
bcx = drop_ty(bcx, llfld_a, fld.mt.ty);
}