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

correct translation of neg. numbers in 64-bit architectures

Browse source
This commit is contained in:
Niko Matsakis 2011-11-13 21:34:58 -08:00
parent 5cabfb3a39
commit 96cdfa11db
2 changed files with 11 additions and 17 deletions
Download patch file Download diff file Expand all files Collapse all files

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

@ -2142,7 +2142,7 @@ fn trans_crate_lit(cx: @crate_ctxt, lit: ast::lit) -> ValueRef {
ast::ty_i32. { t = T_i32(); }
ast::ty_i64. { t = T_i64(); }
}
ret C_integral(t, i as uint, s);
ret C_integral(t, i as u64, s);
}
ast::lit_float(fs) { ret C_float(cx, fs); }
ast::lit_mach_float(tm, s) {
@ -2150,7 +2150,7 @@ fn trans_crate_lit(cx: @crate_ctxt, lit: ast::lit) -> ValueRef {
alt tm { ast::ty_f32. { t = T_f32(); } ast::ty_f64. { t = T_f64(); } }
ret C_floating(s, t);
}
ast::lit_char(c) { ret C_integral(T_char(), c as uint, False); }
ast::lit_char(c) { ret C_integral(T_char(), c as u64, False); }
ast::lit_bool(b) { ret C_bool(b); }
ast::lit_nil. { ret C_nil(); }
ast::lit_str(s) {

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

@ -724,14 +724,8 @@ fn T_opaque_chan_ptr() -> TypeRef { ret T_ptr(T_i8()); }
// LLVM constant constructors.
fn C_null(t: TypeRef) -> ValueRef { ret llvm::LLVMConstNull(t); }
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(.int_type, t as LLVM::ULongLong, False);
//
ret llvm::LLVMRustConstSmallInt(t, u, sign_extend);
fn C_integral(t: TypeRef, u: u64, sign_extend: Bool) -> ValueRef {
ret llvm::LLVMConstInt(t, u, sign_extend);
}
fn C_float(cx: @crate_ctxt, s: str) -> ValueRef {
@ -747,28 +741,28 @@ fn C_floating(s: str, t: TypeRef) -> ValueRef {
fn C_nil() -> ValueRef {
// NB: See comment above in T_void().
ret C_integral(T_i1(), 0u, False);
ret C_integral(T_i1(), 0u64, False);
}
fn C_bool(b: bool) -> ValueRef {
if b {
ret C_integral(T_bool(), 1u, False);
} else { ret C_integral(T_bool(), 0u, False); }
ret C_integral(T_bool(), 1u64, False);
} else { ret C_integral(T_bool(), 0u64, False); }
}
fn C_i32(i: i32) -> ValueRef {
ret C_integral(T_i32(), i as uint, True);
ret C_integral(T_i32(), i as u64, True);
}
fn C_int(cx: @crate_ctxt, i: int) -> ValueRef {
ret C_integral(cx.int_type, i as uint, True);
ret C_integral(cx.int_type, i as u64, True);
}
fn C_uint(cx: @crate_ctxt, i: uint) -> ValueRef {
ret C_integral(cx.int_type, i, False);
ret C_integral(cx.int_type, i as u64, False);
}
fn C_u8(i: uint) -> ValueRef { ret C_integral(T_i8(), i, False); }
fn C_u8(i: uint) -> ValueRef { ret C_integral(T_i8(), i as u64, False); }
// This is a 'c-like' raw string, which differs from