correct translation of neg. numbers in 64-bit architectures

Author: nikomatsakis

src/comp/middle/trans.rs

@@ -2142,15 +2142,15 @@ 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) {
         let t = cx.float_type;
         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) {

src/comp/middle/trans_common.rs

@@ -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