---

yaml
---
r: 101865
b: refs/heads/master
c: 500d29b
h: refs/heads/master
i:
  101863: e900571
v: v3

Author: dotdash

[refs]

@@ -1,5 +1,5 @@
 ---
-refs/heads/master: adea48abb730bfcfdc7008f6bc5964ed5b1e7ca6
+refs/heads/master: 500d29b589a608357c1b82e4203dc1b77454c78c
 refs/heads/snap-stage1: e33de59e47c5076a89eadeb38f4934f58a3618a6
 refs/heads/snap-stage3: 6e7f170fedd3c526a643c0b2d13863acd982be02
 refs/heads/try: a97642026c18a624ff6ea01075dd9550f8ed07ff

trunk/src/librustc/middle/trans/base.rs

@@ -273,7 +273,15 @@ pub fn decl_rust_fn(ccx: &CrateContext, has_env: bool,
                     llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
                 }
             }
-            _ => {}
+            _ => {
+                // For non-immediate arguments the callee gets its own copy of
+                // the value on the stack, so there are no aliases
+                if !type_is_immediate(ccx, arg_ty) {
+                    unsafe {
+                        llvm::LLVMAddAttribute(llarg, lib::llvm::NoAliasAttribute as c_uint);
+                    }
+                }
+            }
         }
     }
 

trunk/src/test/bench/noise.rs

@@ -8,112 +8,128 @@
 // option. This file may not be copied, modified, or distributed
 // except according to those terms.
 
-// Multi-language Perlin noise benchmark.
-// See https://github.com/nsf/pnoise for timings and alternative implementations.
+// Perlin noise benchmark from https://gist.github.com/1170424
 
-use std::f32::consts::PI;
-use std::rand::{Rng, StdRng};
+use std::f64;
+use std::rand::Rng;
+use std::rand;
 
 struct Vec2 {
     x: f32,
     y: f32,
 }
 
+#[inline(always)]
 fn lerp(a: f32, b: f32, v: f32) -> f32 { a * (1.0 - v) + b * v }
 
+#[inline(always)]
 fn smooth(v: f32) -> f32 { v * v * (3.0 - 2.0 * v) }
 
-fn random_gradient<R: Rng>(r: &mut R) -> Vec2 {
-    let v = PI * 2.0 * r.gen();
-    Vec2 { x: v.cos(), y: v.sin() }
+fn random_gradient<R:Rng>(r: &mut R) -> Vec2 {
+    let v = 2.0 * f64::consts::PI * r.gen();
+    Vec2 {
+        x: v.cos() as f32,
+        y: v.sin() as f32,
+    }
 }
 
 fn gradient(orig: Vec2, grad: Vec2, p: Vec2) -> f32 {
-    (p.x - orig.x) * grad.x + (p.y - orig.y) * grad.y
+    let sp = Vec2 {x: p.x - orig.x, y: p.y - orig.y};
+    grad.x * sp.x + grad.y * sp.y
 }
 
 struct Noise2DContext {
     rgradients: [Vec2, ..256],
-    permutations: [i32, ..256],
+    permutations: [int, ..256],
 }
 
 impl Noise2DContext {
-    fn new() -> Noise2DContext {
-        let mut rng = StdRng::new();
-
-        let mut rgradients = [Vec2 { x: 0.0, y: 0.0 }, ..256];
-        for x in rgradients.mut_iter() {
-            *x = random_gradient(&mut rng);
+    pub fn new() -> Noise2DContext {
+        let mut r = rand::rng();
+        let mut rgradients = [ Vec2 { x: 0.0, y: 0.0 }, ..256 ];
+        for i in range(0, 256) {
+            rgradients[i] = random_gradient(&mut r);
         }
-
-        let mut permutations = [0i32, ..256];
-        for (i, x) in permutations.mut_iter().enumerate() {
-            *x = i as i32;
+        let mut permutations = [ 0, ..256 ];
+        for i in range(0, 256) {
+            permutations[i] = i;
         }
-        rng.shuffle_mut(permutations);
+        r.shuffle_mut(permutations);
 
-        Noise2DContext { rgradients: rgradients, permutations: permutations }
+        Noise2DContext {
+            rgradients: rgradients,
+            permutations: permutations,
+        }
     }
 
-    fn get_gradient(&self, x: i32, y: i32) -> Vec2 {
+    #[inline(always)]
+    pub fn get_gradient(&self, x: int, y: int) -> Vec2 {
         let idx = self.permutations[x & 255] + self.permutations[y & 255];
         self.rgradients[idx & 255]
     }
 
-    fn get_gradients(&self, x: f32, y: f32) -> ([Vec2, ..4], [Vec2, ..4]) {
+    #[inline]
+    pub fn get_gradients(&self,
+                         gradients: &mut [Vec2, ..4],
+                         origins: &mut [Vec2, ..4],
+                         x: f32,
+                         y: f32) {
         let x0f = x.floor();
         let y0f = y.floor();
-        let x1f = x0f + 1.0;
-        let y1f = y0f + 1.0;
-
-        let x0 = x0f as i32;
-        let y0 = y0f as i32;
+        let x0 = x0f as int;
+        let y0 = y0f as int;
         let x1 = x0 + 1;
         let y1 = y0 + 1;
 
-        ([self.get_gradient(x0, y0), self.get_gradient(x1, y0),
-          self.get_gradient(x0, y1), self.get_gradient(x1, y1)],
-         [Vec2 { x: x0f, y: y0f }, Vec2 { x: x1f, y: y0f },
-          Vec2 { x: x0f, y: y1f }, Vec2 { x: x1f, y: y1f }])
+        gradients[0] = self.get_gradient(x0, y0);
+        gradients[1] = self.get_gradient(x1, y0);
+        gradients[2] = self.get_gradient(x0, y1);
+        gradients[3] = self.get_gradient(x1, y1);
+
+        origins[0] = Vec2 {x: x0f + 0.0, y: y0f + 0.0};
+        origins[1] = Vec2 {x: x0f + 1.0, y: y0f + 0.0};
+        origins[2] = Vec2 {x: x0f + 0.0, y: y0f + 1.0};
+        origins[3] = Vec2 {x: x0f + 1.0, y: y0f + 1.0};
     }
 
-    fn get(&self, x: f32, y: f32) -> f32 {
+    #[inline]
+    pub fn get(&self, x: f32, y: f32) -> f32 {
         let p = Vec2 {x: x, y: y};
-        let (gradients, origins) = self.get_gradients(x, y);
-
+        let mut gradients = [ Vec2 { x: 0.0, y: 0.0 }, ..4 ];
+        let mut origins = [ Vec2 { x: 0.0, y: 0.0 }, ..4 ];
+        self.get_gradients(&mut gradients, &mut origins, x, y);
         let v0 = gradient(origins[0], gradients[0], p);
         let v1 = gradient(origins[1], gradients[1], p);
         let v2 = gradient(origins[2], gradients[2], p);
         let v3 = gradient(origins[3], gradients[3], p);
-
         let fx = smooth(x - origins[0].x);
         let vx0 = lerp(v0, v1, fx);
         let vx1 = lerp(v2, v3, fx);
         let fy = smooth(y - origins[0].y);
-
         lerp(vx0, vx1, fy)
     }
 }
 
 fn main() {
-    let symbols = [' ', '░', '▒', '▓', '█', '█'];
+    let symbols = [" ", "░", "▒", "▓", "█", "█"];
     let mut pixels = [0f32, ..256*256];
-    let n2d = Noise2DContext::new();
-
-    for _ in range(0, 100) {
+    let n2d = ~Noise2DContext::new();
+    for _ in range(0, 100u) {
         for y in range(0, 256) {
             for x in range(0, 256) {
-                let v = n2d.get(x as f32 * 0.1, y as f32 * 0.1);
-                pixels[y*256+x] = v * 0.5 + 0.5;
-            }
-        }
-    }
+                let v = n2d.get(
+                    x as f32 * 0.1f32,
+                    y as f32 * 0.1f32
+                ) * 0.5f32 + 0.5f32;
+                pixels[y*256+x] = v;
+            };
+        };
+    };
 
     for y in range(0, 256) {
         for x in range(0, 256) {
-            let idx = (pixels[y*256+x] / 0.2) as uint;
-            print!("{:c}", symbols[idx]);
+            print!("{}", symbols[(pixels[y*256+x] / 0.2f32) as int]);
         }
-        print!("\n");
+        println!("");
     }
 }