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

work on making the size of ints depend on the target arch

Browse source
This commit is contained in:
Niko Matsakis 2011-10-14 17:00:17 -07:00 • committed by Brian Anderson
parent 9146bb09a1
commit 2521cda1ec
3 changed files with 92 additions and 60 deletions
Download patch file Download diff file Expand all files Collapse all files

98
src/comp/middle/trans.rs
View file

@ -134,9 +134,9 @@ fn type_of_inner(cx: @crate_ctxt, sp: span, t: ty::t)
T_nil() /* ...I guess? */
}
ty::ty_bool. { T_bool() }
ty::ty_int. { T_int(cx) }
ty::ty_float. { T_float(cx) }
ty::ty_uint. { T_int(cx) }
ty::ty_int. { cx.int_type }
ty::ty_float. { cx.float_type }
ty::ty_uint. { cx.int_type }
ty::ty_machine(tm) {
alt tm {
ast::ty_i8. | ast::ty_u8. { T_i8() }
@ -345,8 +345,8 @@ fn get_simple_extern_fn(cx: @block_ctxt,
llmod: ModuleRef,
name: str, n_args: int) -> ValueRef {
let ccx = cx.fcx.lcx.ccx;
let inputs = std::vec::init_elt::<TypeRef>(T_int(ccx), n_args as uint);
let output = T_int(ccx);
let inputs = std::vec::init_elt::<TypeRef>(ccx.int_type, n_args as uint);
let output = ccx.int_type;
let t = T_fn(inputs, output);
ret get_extern_fn(externs, llmod, name, lib::llvm::LLVMCCallConv, t);
}
@ -405,12 +405,12 @@ fn llalign_of_real(cx: @crate_ctxt, t: TypeRef) -> uint {
}
fn llsize_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef {
ret llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMSizeOf(t), T_int(cx),
ret llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMSizeOf(t), cx.int_type,
False);
}
fn llalign_of(cx: @crate_ctxt, t: TypeRef) -> ValueRef {
ret llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMAlignOf(t), T_int(cx),
ret llvm::LLVMConstIntCast(lib::llvm::llvm::LLVMAlignOf(t), cx.int_type,
False);
}
@ -597,7 +597,7 @@ fn dynamic_size_of(cx: @block_ctxt, t: ty::t, mode: align_mode) -> result {
let ccx = bcx_ccx(bcx);
// Compute max(variant sizes).
let max_size: ValueRef = alloca(bcx, T_int(ccx));
let max_size: ValueRef = alloca(bcx, ccx.int_type);
Store(bcx, C_int(ccx, 0), max_size);
let variants = ty::tag_variants(bcx_tcx(bcx), tid);
for variant: ty::variant_info in variants {
@ -618,7 +618,7 @@ fn dynamic_size_of(cx: @block_ctxt, t: ty::t, mode: align_mode) -> result {
let max_size_val = Load(bcx, max_size);
let total_size =
if std::vec::len(variants) != 1u {
Add(bcx, max_size_val, llsize_of(ccx, T_int(ccx)))
Add(bcx, max_size_val, llsize_of(ccx, ccx.int_type))
} else { max_size_val };
ret rslt(bcx, total_size);
}
@ -2161,7 +2161,7 @@ fn trans_crate_lit(cx: @crate_ctxt, lit: ast::lit) -> ValueRef {
// if target int width is larger than host, at the moment;
// re-do the mach-int types using 'big' when that works.
let t = T_int(cx);
let t = cx.int_type;
let s = True;
alt tm {
ast::ty_u8. { t = T_i8(); s = False; }
@ -2177,7 +2177,7 @@ fn trans_crate_lit(cx: @crate_ctxt, lit: ast::lit) -> ValueRef {
}
ast::lit_float(fs) { ret C_float(cx, fs); }
ast::lit_mach_float(tm, s) {
let t = T_float(cx);
let t = cx.float_type;
alt tm { ast::ty_f32. { t = T_f32(); } ast::ty_f64. { t = T_f64(); } }
ret C_floating(s, t);
}
@ -2961,7 +2961,7 @@ fn lookup_discriminant(lcx: @local_ctxt, vid: ast::def_id) -> ValueRef {
let gvar =
str::as_buf(sym,
{|buf|
llvm::LLVMAddGlobal(ccx.llmod, T_int(ccx), buf)
llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
});
llvm::LLVMSetLinkage(gvar,
lib::llvm::LLVMExternalLinkage as llvm::Linkage);
@ -3120,11 +3120,11 @@ fn trans_index(cx: @block_ctxt, sp: span, base: @ast::expr, idx: @ast::expr,
// Cast to an LLVM integer. Rust is less strict than LLVM in this regard.
let ix_val;
let ix_size = llsize_of_real(bcx_ccx(cx), val_ty(ix.val));
let int_size = llsize_of_real(bcx_ccx(cx), T_int(ccx));
let int_size = llsize_of_real(bcx_ccx(cx), ccx.int_type);
if ix_size < int_size {
ix_val = ZExt(bcx, ix.val, T_int(ccx));
ix_val = ZExt(bcx, ix.val, ccx.int_type);
} else if ix_size > int_size {
ix_val = Trunc(bcx, ix.val, T_int(ccx));
ix_val = Trunc(bcx, ix.val, ccx.int_type);
} else { ix_val = ix.val; }
let unit_ty = node_id_type(bcx_ccx(cx), id);
@ -4420,10 +4420,10 @@ fn trans_log(lvl: int, cx: @block_ctxt, e: @ast::expr) -> @block_ctxt {
let s = link::mangle_internal_name_by_path_and_seq(
lcx.ccx, lcx.module_path, "loglevel");
let global = str::as_buf(s, {|buf|
llvm::LLVMAddGlobal(lcx.ccx.llmod, T_int(ccx), buf)
llvm::LLVMAddGlobal(lcx.ccx.llmod, ccx.int_type, buf)
});
llvm::LLVMSetGlobalConstant(global, False);
llvm::LLVMSetInitializer(global, C_null(T_int(ccx)));
llvm::LLVMSetInitializer(global, C_null(ccx.int_type));
llvm::LLVMSetLinkage(global,
lib::llvm::LLVMInternalLinkage as llvm::Linkage);
lcx.ccx.module_data.insert(modname, global);
@ -5651,14 +5651,14 @@ fn register_native_fn(ccx: @crate_ctxt, sp: span, path: [str], name: str,
cast_to_i32 = true;
}
ast::native_abi_c_stack_cdecl. {
let llfn = decl_cdecl_fn(ccx.llmod, name, T_fn([], T_int()));
let llfn = decl_cdecl_fn(ccx.llmod, name, T_fn([], ccx.int_type));
ccx.item_ids.insert(id, llfn);
ccx.item_symbols.insert(id, name);
ret;
}
ast::native_abi_c_stack_stdcall. {
let llfn = decl_fn(ccx.llmod, name, lib::llvm::LLVMX86StdcallCallConv,
T_fn([], T_int()));
T_fn([], ccx.int_type));
ccx.item_ids.insert(id, llfn);
ccx.item_symbols.insert(id, name);
ret;
@ -5706,21 +5706,23 @@ fn register_native_fn(ccx: @crate_ctxt, sp: span, path: [str], name: str,
fn convert_arg_to_i32(cx: @block_ctxt, v: ValueRef, t: ty::t,
mode: ty::mode) -> ValueRef {
if mode == ast::by_ref || mode == ast::by_val {
let ccx = bcx_ccx(cx);
if ty::type_is_integral(bcx_tcx(cx), t) {
// FIXME: would be nice to have a postcondition that says
// if a type is integral, then it has static size (#586)
let lldsttype = T_int();
let ccx = bcx_ccx(cx);
let lldsttype = ccx.int_type;
let sp = cx.sp;
check (type_has_static_size(ccx, t));
let llsrctype = type_of(ccx, sp, t);
if llvm::LLVMGetIntTypeWidth(lldsttype) >
llvm::LLVMGetIntTypeWidth(llsrctype) {
ret ZExtOrBitCast(cx, v, T_int());
ret ZExtOrBitCast(cx, v, ccx.int_type);
}
ret TruncOrBitCast(cx, v, T_int());
ret TruncOrBitCast(cx, v, ccx.int_type);
}
if ty::type_is_fp(bcx_tcx(cx), t) {
ret FPToSI(cx, v, ccx.int_type);
}
if ty::type_is_fp(bcx_tcx(cx), t) { ret FPToSI(cx, v, T_int()); }
}
ret vp2i(cx, v);
}
@ -5927,11 +5929,10 @@ fn trans_constant(ccx: @crate_ctxt, it: @ast::item, &&pt: [str],
let p = new_pt + [it.ident, variant.node.name, "discrim"];
let s = mangle_exported_name(ccx, p, ty::mk_int(ccx.tcx));
let discrim_gvar =
str::as_buf(s,
{|buf|
llvm::LLVMAddGlobal(ccx.llmod, T_int(), buf)
});
llvm::LLVMSetInitializer(discrim_gvar, C_int(i as int));
str::as_buf(s, {|buf|
llvm::LLVMAddGlobal(ccx.llmod, ccx.int_type, buf)
});
llvm::LLVMSetInitializer(discrim_gvar, C_int(ccx, i as int));
llvm::LLVMSetGlobalConstant(discrim_gvar, True);
ccx.discrims.insert(
ast_util::local_def(variant.node.id), discrim_gvar);
@ -5951,10 +5952,13 @@ fn trans_constants(ccx: @crate_ctxt, crate: @ast::crate) {
}
fn vp2i(cx: @block_ctxt, v: ValueRef) -> ValueRef {
ret PtrToInt(cx, v, T_int());
let ccx = bcx_ccx(cx);
ret PtrToInt(cx, v, ccx.int_type);
}
fn p2i(v: ValueRef) -> ValueRef { ret llvm::LLVMConstPtrToInt(v, T_int()); }
fn p2i(ccx: @crate_ctxt, v: ValueRef) -> ValueRef {
ret llvm::LLVMConstPtrToInt(v, ccx.int_type);
}
fn declare_intrinsics(llmod: ModuleRef) -> hashmap<str, ValueRef> {
let T_memmove32_args: [TypeRef] =
@ -6005,7 +6009,7 @@ fn trap(bcx: @block_ctxt) {
}
fn create_module_map(ccx: @crate_ctxt) -> ValueRef {
let elttype = T_struct([T_int(), T_int()]);
let elttype = T_struct([ccx.int_type, ccx.int_type]);
let maptype = T_array(elttype, ccx.module_data.size() + 1u);
let map =
str::as_buf("_rust_mod_map",
@ -6057,6 +6061,24 @@ fn fill_crate_map(ccx: @crate_ctxt, map: ValueRef) {
subcrates += [C_int(0)];
llvm::LLVMSetInitializer(map, C_struct([p2i(create_module_map(ccx)),
C_array(T_int(), subcrates)]));
subcrates += [C_int(ccx, 0)];
let mapname;
if ccx.sess.get_opts().library {
mapname = ccx.link_meta.name;
} else { mapname = "toplevel"; }
let sym_name = "_rust_crate_map_" + mapname;
let arrtype = T_array(ccx.int_type, std::vec::len::<ValueRef>(subcrates));
let maptype = T_struct([ccx.int_type, arrtype]);
let map =
str::as_buf(sym_name,
{|buf| llvm::LLVMAddGlobal(ccx.llmod, maptype, buf) });
llvm::LLVMSetLinkage(map,
lib::llvm::LLVMExternalLinkage as llvm::Linkage);
llvm::LLVMSetInitializer(map,
C_struct([p2i(create_module_map(ccx)),
C_array(ccx.int_type, subcrates)]));
ret map;
>>>>>>> work on making the size of ints depend on the target arch
}
fn write_metadata(cx: @crate_ctxt, crate: @ast::crate) {
@ -6090,7 +6112,7 @@ fn write_metadata(cx: @crate_ctxt, crate: @ast::crate) {
// Writes the current ABI version into the crate.
fn write_abi_version(ccx: @crate_ctxt) {
shape::mk_global(ccx, "rust_abi_version", C_uint(abi::abi_version),
shape::mk_global(ccx, "rust_abi_version", C_uint(ccx, abi::abi_version),
false);
}
@ -6110,8 +6132,12 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
let td = mk_target_data(sess.get_targ_cfg().target_strs.data_layout);
let tn = mk_type_names();
let intrinsics = declare_intrinsics(llmod);
let task_type = T_task();
let tydesc_type = T_tydesc();
let int_type = T_int(sess.get_targ_cfg().arch);
let float_type = T_float(sess.get_targ_cfg().arch);
let task_type = T_task(sess.get_targ_cfg().arch);
let taskptr_type = T_ptr(task_type);
tn.associate("taskptr", taskptr_type);
let tydesc_type = T_tydesc(taskptr_type);
tn.associate("tydesc", tydesc_type);
let hasher = ty::hash_ty;
let eqer = ty::eq_ty;
@ -6161,6 +6187,8 @@ fn trans_crate(sess: session::session, crate: @ast::crate, tcx: ty::ctxt,
upcall::declare_upcalls(tn, tydesc_type, llmod),
rust_object_type: T_rust_object(),
tydesc_type: tydesc_type,
int_type: int_type,
float_type: float_type,
task_type: task_type,
builder: BuilderRef_res(llvm::LLVMCreateBuilder()),
shape_cx: shape::mk_ctxt(llmod),

6
src/comp/middle/trans_build.rs
View file

@ -306,7 +306,7 @@ fn Load(cx: @block_ctxt, PointerVal: ValueRef) -> ValueRef {
if cx.unreachable {
let ty = val_ty(PointerVal);
let eltty = if llvm::LLVMGetTypeKind(ty) == 11 {
llvm::LLVMGetElementType(ty) } else { T_int(ccx) };
llvm::LLVMGetElementType(ty) } else { ccx.int_type };
ret llvm::LLVMGetUndef(eltty);
}
ret llvm::LLVMBuildLoad(B(cx), PointerVal, noname());
@ -492,7 +492,7 @@ fn _UndefReturn(cx: @block_ctxt, Fn: ValueRef) -> ValueRef {
let ccx = cx.fcx.lcx.ccx;
let ty = val_ty(Fn);
let retty = if llvm::LLVMGetTypeKind(ty) == 8 {
llvm::LLVMGetReturnType(ty) } else { T_int(ccx) };
llvm::LLVMGetReturnType(ty) } else { ccx.int_type };
ret llvm::LLVMGetUndef(retty);
}
@ -577,7 +577,7 @@ fn IsNotNull(cx: @block_ctxt, Val: ValueRef) -> ValueRef {
fn PtrDiff(cx: @block_ctxt, LHS: ValueRef, RHS: ValueRef) -> ValueRef {
let ccx = cx.fcx.lcx.ccx;
if cx.unreachable { ret llvm::LLVMGetUndef(T_int(ccx)); }
if cx.unreachable { ret llvm::LLVMGetUndef(ccx.int_type); }
ret llvm::LLVMBuildPtrDiff(B(cx), LHS, RHS, noname());
}

48
src/comp/middle/trans_common.rs
View file

@ -120,6 +120,8 @@ type crate_ctxt =
upcalls: @upcall::upcalls,
rust_object_type: TypeRef,
tydesc_type: TypeRef,
int_type: TypeRef,
float_type: TypeRef,
task_type: TypeRef,
builder: BuilderRef_res,
shape_cx: shape::ctxt,
@ -488,16 +490,16 @@ fn T_f64() -> TypeRef { ret llvm::LLVMDoubleType(); }
fn T_bool() -> TypeRef { ret T_i1(); }
fn T_int(cx: @crate_ctxt) -> TypeRef {
ret alt cx.sess.get_targ_cfg().arch {
fn T_int(arch: session::arch) -> TypeRef {
ret alt arch {
arch_x86 { T_i32() }
arch_x86_64 { T_i64() }
arch_arm { T_i32() }
};
}
fn T_float(cx: @crate_ctxt) -> TypeRef {
ret alt cx.sess.get_targ_cfg().arch {
fn T_float(arch: session::arch) -> TypeRef {
ret alt arch {
arch_x86 { T_f64() }
arch_x86_64 { T_f64() }
arch_arm { T_f64() }
@ -507,7 +509,7 @@ fn T_float(cx: @crate_ctxt) -> TypeRef {
fn T_char() -> TypeRef { ret T_i32(); }
fn T_size_t(cx: @crate_ctxt) -> TypeRef {
ret T_int(cx);
ret cx.int_type;
}
fn T_fn(inputs: [TypeRef], output: TypeRef) -> TypeRef {
@ -551,7 +553,7 @@ fn T_rust_object() -> TypeRef {
ret t;
}
fn T_task(cx: @crate_ctxt) -> TypeRef {
fn T_task(arch: session::arch) -> TypeRef {
let t = T_named_struct("task");
// Refcount
@ -565,9 +567,10 @@ fn T_task(cx: @crate_ctxt) -> TypeRef {
// Domain pointer
// Crate cache pointer
let t_int = T_int(arch);
let elems =
[T_int(cx), T_int(cx), T_int(cx), T_int(cx),
T_int(cx), T_int(cx), T_int(cx), T_int(cx)];
[t_int, t_int, t_int, t_int,
t_int, t_int, t_int, t_int];
set_struct_body(t, elems);
ret t;
}
@ -612,9 +615,10 @@ fn T_tydesc(cx: @crate_ctxt) -> TypeRef {
pvoid, pvoid, T_i8()], T_void()));
let elems =
[tydescpp, T_int(cx), T_int(cx), glue_fn_ty, glue_fn_ty, glue_fn_ty,
[tydescpp, cx.int_type, cx.int_type,
glue_fn_ty, glue_fn_ty, glue_fn_ty,
T_ptr(T_i8()), glue_fn_ty, glue_fn_ty, glue_fn_ty, cmp_glue_fn_ty,
T_ptr(T_i8()), T_ptr(T_i8()), T_int(cx), T_int(cx)];
T_ptr(T_i8()), T_ptr(T_i8()), cx.int_type, cx.int_type];
set_struct_body(tydesc, elems);
ret tydesc;
}
@ -626,8 +630,8 @@ fn T_array(t: TypeRef, n: uint) -> TypeRef { ret llvm::LLVMArrayType(t, n); }
//
// TODO: Support user-defined vector sizes.
fn T_vec(cx: @crate_ctxt, t: TypeRef) -> TypeRef {
ret T_struct([T_int(cx), // fill
T_int(cx), // alloc
ret T_struct([cx.int_type, // fill
cx.int_type, // alloc
T_array(t, 0u)]); // elements
}
@ -635,16 +639,16 @@ fn T_vec(cx: @crate_ctxt, t: TypeRef) -> TypeRef {
fn T_opaque_vec(cx: @crate_ctxt) -> TypeRef { ret T_vec(cx, T_i8()); }
fn T_box(cx: @crate_ctxt, t: TypeRef) -> TypeRef {
ret T_struct([T_int(cx), t]);
ret T_struct([cx.int_type, t]);
}
fn T_port(cx: @crate_ctxt, _t: TypeRef) -> TypeRef {
ret T_struct([T_int(cx)]); // Refcount
ret T_struct([cx.int_type]); // Refcount
}
fn T_chan(cx: @crate_ctxt, _t: TypeRef) -> TypeRef {
ret T_struct([T_int(cx)]); // Refcount
ret T_struct([cx.int_type]); // Refcount
}
@ -684,8 +688,8 @@ fn T_tag(cx: @crate_ctxt, size: uint) -> TypeRef {
if cx.tn.name_has_type(s) { ret cx.tn.get_type(s); }
let t =
if size == 0u {
T_struct([T_int(cx)])
} else { T_struct([T_int(cx), T_array(T_i8(), size)]) };
T_struct([cx.int_type])
} else { T_struct([cx.int_type, T_array(T_i8(), size)]) };
cx.tn.associate(s, t);
ret t;
}
@ -693,7 +697,7 @@ fn T_tag(cx: @crate_ctxt, size: uint) -> TypeRef {
fn T_opaque_tag(cx: @crate_ctxt) -> TypeRef {
let s = "opaque_tag";
if cx.tn.name_has_type(s) { ret cx.tn.get_type(s); }
let t = T_struct([T_int(cx), T_i8()]);
let t = T_struct([cx.int_type, T_i8()]);
cx.tn.associate(s, t);
ret t;
}
@ -731,7 +735,7 @@ fn C_integral(t: TypeRef, u: uint, sign_extend: Bool) -> ValueRef {
// FIXME: We can't use LLVM::ULongLong with our existing minimal native
// API, which only knows word-sized args.
//
// ret llvm::LLVMConstInt(T_int(), t as LLVM::ULongLong, False);
// ret llvm::LLVMConstInt(.int_type, t as LLVM::ULongLong, False);
//
ret llvm::LLVMRustConstSmallInt(t, u, sign_extend);
@ -739,7 +743,7 @@ fn C_integral(t: TypeRef, u: uint, sign_extend: Bool) -> ValueRef {
fn C_float(cx: @crate_ctxt, s: str) -> ValueRef {
ret str::as_buf(s, {|buf|
llvm::LLVMConstRealOfString(T_float(cx), buf)
llvm::LLVMConstRealOfString(cx.float_type, buf)
});
}
@ -760,11 +764,11 @@ fn C_bool(b: bool) -> ValueRef {
}
fn C_int(cx: @crate_ctxt, i: int) -> ValueRef {
ret C_integral(T_int(cx), i as uint, True);
ret C_integral(cx.int_type, i as uint, True);
}
fn C_uint(cx: @crate_ctxt, i: uint) -> ValueRef {
ret C_integral(T_int(cx), i, False);
ret C_integral(cx.int_type, i, False);
}
fn C_u8(i: uint) -> ValueRef { ret C_integral(T_i8(), i, False); }