---

yaml
---
r: 16300
b: refs/heads/try
c: ef32ffd
h: refs/heads/master
v: v3

Author: brson

[refs]

@@ -2,5 +2,5 @@
 refs/heads/master: 61b1875c16de39c166b0f4d54bba19f9c6777d1a
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 4a81779abd786ff22d71434c6d9a5917ea4cdfff
-refs/heads/try: db31969d4a10316169cfce858e10742cd588575e
+refs/heads/try: ef32ffd0b1602ff87536508a7f75fd9b1510b4e9
 refs/tags/release-0.1: 1f5c5126e96c79d22cb7862f75304136e204f105

branches/try/src/rustc/back/link.rs

@@ -637,6 +637,11 @@ fn link_binary(sess: session,
     // and binutils 2.22+ won't add them automatically
     if sess.targ_cfg.os == session::os_linux {
         cc_args += ["-lrt", "-ldl"];
+
+        // LLVM implements the `frem` instruction as a call to `fmod`,
+        // which lives in libm. Similar to above, on some linuxes we
+        // have to be explicit about linking to it. See #2510
+        cc_args += ["-lm"];
     }
 
     if sess.targ_cfg.os == session::os_freebsd {

branches/try/src/rustc/middle/ty.rs

@@ -1678,8 +1678,11 @@ fn is_instantiable(cx: ctxt, r_ty: t) -> bool {
 
           ty_class(did, substs) {
             vec::push(*seen, did);
-            let r = vec::any(class_items_as_fields(cx, did, substs)) {|f|
-                      type_requires(cx, seen, r_ty, f.mt.ty)};
+            let r = vec::any(lookup_class_fields(cx, did)) {|f|
+                let fty = ty::lookup_item_type(cx, f.id);
+                let sty = subst(cx, substs, fty.ty);
+                type_requires(cx, seen, r_ty, sty)
+            };
             vec::pop(*seen);
             r
           }

branches/try/src/snapshots.txt

@@ -1,3 +1,11 @@
+S 2012-06-05 fec3b91
+  winnt-i386 36348a2b016f25d9e3b7e1a8814a352c18123839
+  linux-x86_64 7308f0eb3d6a9985c14dfbbde7e1f9eb901cc966
+  linux-i386 d4c1e1733fd30945f96ae67dbc10289f2a9ec380
+  freebsd-x86_64 d0ee6054d7d8320d64aa4dbb9b041537fa2665d5
+  macos-x86_64 652501172b4fee6631f595c90538fd95914ef444
+  macos-i386 5c54b5ecf54cc2631fdd48caa326ab44b5a2e494
+
 S 2012-06-04 7213274
   winnt-i386 94b9414433fd83c086b349ded3159f0541aace16
   linux-x86_64 eb9cf0de4cc09e8b8bfcf741eff4b20510e13a5b

branches/try/src/test/run-fail/bug-2470-bounds-check-overflow-2.rs

@@ -0,0 +1,17 @@
+// xfail-test
+// error-pattern:bounds check
+
+fn main() {
+    let x = [1u,2u,3u];
+
+    // This should cause a bounds-check failure, but may not if we do our
+    // bounds checking by comparing a scaled index value to the vector's
+    // length (in bytes), because the scaling of the index will cause it to
+    // wrap around to a small number.
+
+    let idx = uint::max_value & !(uint::max_value >> 1u);
+    #error("ov2 idx = 0x%x", idx);
+
+    // This should fail.
+    #error("ov2 0x%x",  x[idx]);
+}

branches/try/src/test/run-fail/bug-2470-bounds-check-overflow-3.rs

@@ -0,0 +1,28 @@
+// xfail-test
+// error-pattern:bounds check
+
+#[cfg(target_arch="x86")]
+fn main() {
+    let x = [1u,2u,3u];
+
+    // This should cause a bounds-check failure, but may not if we do our
+    // bounds checking by truncating the index value to the size of the
+    // machine word, losing relevant bits of the index value.
+
+    // This test is only meaningful on 32-bit hosts.
+
+    let idx = u64::max_value & !(u64::max_value >> 1u);
+    #error("ov3 idx = 0x%8.8x%8.8x",
+           (idx >> 32) as uint,
+           idx as uint);
+
+    // This should fail.
+    #error("ov3 0x%x",  x[idx]);
+}
+
+#[cfg(target_arch="x86_64")]
+fn main() {
+    // This version just fails anyways, for symmetry on 64-bit hosts.
+    let x = [1u,2u,3u];
+    #error("ov3 0x%x",  x[200]);
+}

branches/try/src/test/run-fail/bug-2470-bounds-check-overflow.rs

@@ -0,0 +1,24 @@
+// error-pattern:bounds check
+
+fn main() {
+
+    // This should cause a bounds-check failure, but may not if we do our
+    // bounds checking by comparing the scaled index to the vector's
+    // address-bounds, since we've scaled the index to wrap around to the
+    // address of the 0th cell in the array (even though the index is
+    // huge).
+
+    let x = [1u,2u,3u];
+    vec::unpack_slice(x) {|p, _len|
+        let base = p as uint;                     // base = 0x1230 say
+        let idx = base / sys::size_of::<uint>();  // idx  = 0x0246 say
+        #error("ov1 base = 0x%x", base);
+        #error("ov1 idx = 0x%x", idx);
+        #error("ov1 sizeof::<uint>() = 0x%x", sys::size_of::<uint>());
+        #error("ov1 idx * sizeof::<uint>() = 0x%x",
+               idx * sys::size_of::<uint>());
+
+        // This should fail.
+        #error("ov1 0x%x",  x[idx]);
+    }
+}

branches/try/src/test/run-pass/deep-vector.rs

@@ -1,5 +1,5 @@
 fn main() {
-    let _x = [
+    let x = [
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,
         0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0,