mikros/rust
1
0
Fork 0
Code Issues Pull Requests Packages Projects Releases Wiki Activity

Merge branch 'master' of https://github.com/rust-lang/rust

Browse Source
This commit is contained in:
Michael McConville 2015-12-18 22:37:00 -05:00
commit e8d2706cba
9 changed files with 561 additions and 29 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

2
src/liblibc

@ -1 +1 @@
Subproject commit 867c6ff0b824d6d295951ed34bb252d5e0b2467a
Subproject commit 9863d5645fc4d1be789d03bcf58c1b3cfafbba39

88
src/librustc_trans/trans/mir/block.rs
View File

@ -9,14 +9,18 @@
// except according to those terms.
use llvm::BasicBlockRef;
use middle::infer;
use middle::ty;
use rustc::mir::repr as mir;
use trans::adt;
use trans::base;
use trans::build;
use trans::common::Block;
use trans::common::{self, Block};
use trans::debuginfo::DebugLoc;
use trans::type_of;
use super::MirContext;
use super::operand::OperandValue::{FatPtr, Immediate, Ref};
impl<'bcx, 'tcx> MirContext<'bcx, 'tcx> {
pub fn trans_block(&mut self, bb: mir::BasicBlock) {
@ -101,29 +105,65 @@ pub fn trans_block(&mut self, bb: mir::BasicBlock) {
base::build_return_block(bcx.fcx, bcx, return_ty, DebugLoc::None);
}
mir::Terminator::Call { .. } => {
unimplemented!()
//let llbb = unimplemented!(); // self.make_landing_pad(panic_bb);
//
//let tr_dest = self.trans_lvalue(bcx, &data.destination);
//
//// Create the callee. This will always be a fn
//// ptr and hence a kind of scalar.
//let callee = self.trans_operand(bcx, &data.func);
//
//// Process the arguments.
//
//let args = unimplemented!();
//
//callee::trans_call_inner(bcx,
// DebugLoc::None,
// |bcx, _| Callee {
// bcx: bcx,
// data: CalleeData::Fn(callee.llval),
// ty: callee.ty,
// },
// args,
// Some(Dest::SaveIn(tr_dest.llval)));
mir::Terminator::Call { ref data, targets } => {
// The location we'll write the result of the call into.
let call_dest = self.trans_lvalue(bcx, &data.destination);
// Create the callee. This will always be a fn
// ptr and hence a kind of scalar.
let callee = self.trans_operand(bcx, &data.func);
let ret_ty = if let ty::TyBareFn(_, ref f) = callee.ty.sty {
let sig = bcx.tcx().erase_late_bound_regions(&f.sig);
let sig = infer::normalize_associated_type(bcx.tcx(), &sig);
sig.output
} else {
panic!("trans_block: expected TyBareFn as callee");
};
// The arguments we'll be passing
let mut llargs = vec![];
// Does the fn use an outptr? If so, that's the first arg.
if let ty::FnConverging(ret_ty) = ret_ty {
if type_of::return_uses_outptr(bcx.ccx(), ret_ty) {
llargs.push(call_dest.llval);
}
}
// Process the rest of the args.
for arg in &data.args {
let arg_op = self.trans_operand(bcx, arg);
match arg_op.val {
Ref(llval) | Immediate(llval) => llargs.push(llval),
FatPtr(base, extra) => {
// The two words in a fat ptr are passed separately
llargs.push(base);
llargs.push(extra);
}
}
}
// FIXME: Handle panics
//let panic_bb = self.llblock(targets.1);
//self.make_landing_pad(panic_bb);
// Do the actual call.
let (llret, b) = base::invoke(bcx,
callee.immediate(),
&llargs[..],
callee.ty,
DebugLoc::None);
bcx = b;
// Copy the return value into the destination.
if let ty::FnConverging(ret_ty) = ret_ty {
if !type_of::return_uses_outptr(bcx.ccx(), ret_ty) &&
!common::type_is_zero_size(bcx.ccx(), ret_ty) {
base::store_ty(bcx, llret, call_dest.llval, ret_ty);
}
}
build::Br(bcx, self.llblock(targets.0), DebugLoc::None)
}
}
}

3
src/libstd/ffi/c_str.rs
View File

@ -19,6 +19,7 @@
use iter::Iterator;
use libc;
use mem;
use memchr;
use ops::Deref;
use option::Option::{self, Some, None};
use os::raw::c_char;
@ -188,7 +189,7 @@ pub fn new<T: Into<Vec<u8>>>(t: T) -> Result<CString, NulError> {
}
fn _new(bytes: Vec<u8>) -> Result<CString, NulError> {
match bytes.iter().position(|x| *x == 0) {
match memchr::memchr(0, &bytes) {
Some(i) => Err(NulError(i, bytes)),
None => Ok(unsafe { CString::from_vec_unchecked(bytes) }),
}

3
src/libstd/io/buffered.rs
View File

@ -18,6 +18,7 @@
use error;
use fmt;
use io::{self, DEFAULT_BUF_SIZE, Error, ErrorKind, SeekFrom};
use memchr;
/// The `BufReader` struct adds buffering to any reader.
///
@ -746,7 +747,7 @@ pub fn into_inner(self) -> Result<W, IntoInnerError<LineWriter<W>>> {
#[stable(feature = "rust1", since = "1.0.0")]
impl<W: Write> Write for LineWriter<W> {
fn write(&mut self, buf: &[u8]) -> io::Result<usize> {
match buf.iter().rposition(|b| *b == b'\n') {
match memchr::memrchr(b'\n', buf) {
Some(i) => {
let n = try!(self.inner.write(&buf[..i + 1]));
if n != i + 1 { return Ok(n) }

3
src/libstd/io/mod.rs
View File

@ -254,6 +254,7 @@
use string::String;
use str;
use vec::Vec;
use memchr;
#[stable(feature = "rust1", since = "1.0.0")]
pub use self::buffered::{BufReader, BufWriter, LineWriter};
@ -1194,7 +1195,7 @@ fn read_until<R: BufRead + ?Sized>(r: &mut R, delim: u8, buf: &mut Vec<u8>)
Err(ref e) if e.kind() == ErrorKind::Interrupted => continue,
Err(e) => return Err(e)
};
match available.iter().position(|x| *x == delim) {
match memchr::memchr(delim, available) {
Some(i) => {
buf.extend_from_slice(&available[..i + 1]);
(true, i + 1)

2
src/libstd/lib.rs
View File

@ -248,6 +248,7 @@
#![feature(link_args)]
#![feature(linkage)]
#![feature(macro_reexport)]
#![feature(num_bits_bytes)]
#![feature(on_unimplemented)]
#![feature(oom)]
#![feature(optin_builtin_traits)]
@ -429,6 +430,7 @@
pub mod process;
pub mod sync;
pub mod time;
mod memchr;
#[macro_use]
#[path = "sys/common/mod.rs"] mod sys_common;

386
src/libstd/memchr.rs Normal file
View File

@ -0,0 +1,386 @@
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
//
// Original implementation taken from rust-memchr
// Copyright 2015 Andrew Gallant, bluss and Nicolas Koch
/// A safe interface to `memchr`.
///
/// Returns the index corresponding to the first occurrence of `needle` in
/// `haystack`, or `None` if one is not found.
///
/// memchr reduces to super-optimized machine code at around an order of
/// magnitude faster than `haystack.iter().position(|&b| b == needle)`.
/// (See benchmarks.)
///
/// # Example
///
/// This shows how to find the first position of a byte in a byte string.
///
/// ```rust,ignore
/// use memchr::memchr;
///
/// let haystack = b"the quick brown fox";
/// assert_eq!(memchr(b'k', haystack), Some(8));
/// ```
pub fn memchr(needle: u8, haystack: &[u8]) -> Option<usize> {
// libc memchr
#[cfg(not(target_os = "windows"))]
fn memchr_specific(needle: u8, haystack: &[u8]) -> Option<usize> {
use libc;
let p = unsafe {
libc::memchr(
haystack.as_ptr() as *const libc::c_void,
needle as libc::c_int,
haystack.len() as libc::size_t)
};
if p.is_null() {
None
} else {
Some(p as usize - (haystack.as_ptr() as usize))
}
}
// use fallback on windows, since it's faster
#[cfg(target_os = "windows")]
fn memchr_specific(needle: u8, haystack: &[u8]) -> Option<usize> {
fallback::memchr(needle, haystack)
}
memchr_specific(needle, haystack)
}
/// A safe interface to `memrchr`.
///
/// Returns the index corresponding to the last occurrence of `needle` in
/// `haystack`, or `None` if one is not found.
///
/// # Example
///
/// This shows how to find the last position of a byte in a byte string.
///
/// ```rust,ignore
/// use memchr::memrchr;
///
/// let haystack = b"the quick brown fox";
/// assert_eq!(memrchr(b'o', haystack), Some(17));
/// ```
pub fn memrchr(needle: u8, haystack: &[u8]) -> Option<usize> {
#[cfg(target_os = "linux")]
fn memrchr_specific(needle: u8, haystack: &[u8]) -> Option<usize> {
use libc;
// GNU's memrchr() will - unlike memchr() - error if haystack is empty.
if haystack.is_empty() {return None}
let p = unsafe {
libc::memrchr(
haystack.as_ptr() as *const libc::c_void,
needle as libc::c_int,
haystack.len() as libc::size_t)
};
if p.is_null() {
None
} else {
Some(p as usize - (haystack.as_ptr() as usize))
}
}
#[cfg(not(target_os = "linux"))]
fn memrchr_specific(needle: u8, haystack: &[u8]) -> Option<usize> {
haystack.iter().rposition(|&b| b == needle)
}
memrchr_specific(needle, haystack)
}
#[allow(dead_code)]
mod fallback {
use cmp;
use usize;
const LO_U64: u64 = 0x0101010101010101;
const HI_U64: u64 = 0x8080808080808080;
// use truncation
const LO_USIZE: usize = LO_U64 as usize;
const HI_USIZE: usize = HI_U64 as usize;
/// Return `true` if `x` contains any zero byte.
///
/// From *Matters Computational*, J. Arndt
///
/// "The idea is to subtract one from each of the bytes and then look for
/// bytes where the borrow propagated all the way to the most significant
/// bit."
#[inline]
fn contains_zero_byte(x: usize) -> bool {
x.wrapping_sub(LO_USIZE) & !x & HI_USIZE != 0
}
#[cfg(target_pointer_width = "32")]
#[inline]
fn repeat_byte(b: u8) -> usize {
let mut rep = (b as usize) << 8 | b as usize;
rep = rep << 16 | rep;
rep
}
#[cfg(target_pointer_width = "64")]
#[inline]
fn repeat_byte(b: u8) -> usize {
let mut rep = (b as usize) << 8 | b as usize;
rep = rep << 16 | rep;
rep = rep << 32 | rep;
rep
}
/// Return the first index matching the byte `a` in `text`.
pub fn memchr(x: u8, text: &[u8]) -> Option<usize> {
// Scan for a single byte value by reading two `usize` words at a time.
//
// Split `text` in three parts
// - unaligned inital part, before the first word aligned address in text
// - body, scan by 2 words at a time
// - the last remaining part, < 2 word size
let len = text.len();
let ptr = text.as_ptr();
// search up to an aligned boundary
let align = (ptr as usize) & (usize::BYTES- 1);
let mut offset;
if align > 0 {
offset = cmp::min(usize::BYTES - align, len);
if let Some(index) = text[..offset].iter().position(|elt| *elt == x) {
return Some(index);
}
} else {
offset = 0;
}
// search the body of the text
let repeated_x = repeat_byte(x);
if len >= 2 * usize::BYTES {
while offset <= len - 2 * usize::BYTES {
unsafe {
let u = *(ptr.offset(offset as isize) as *const usize);
let v = *(ptr.offset((offset + usize::BYTES) as isize) as *const usize);
// break if there is a matching byte
let zu = contains_zero_byte(u ^ repeated_x);
let zv = contains_zero_byte(v ^ repeated_x);
if zu || zv {
break;
}
}
offset += usize::BYTES * 2;
}
}
// find the byte after the point the body loop stopped
text[offset..].iter().position(|elt| *elt == x).map(|i| offset + i)
}
/// Return the last index matching the byte `a` in `text`.
pub fn memrchr(x: u8, text: &[u8]) -> Option<usize> {
// Scan for a single byte value by reading two `usize` words at a time.
//
// Split `text` in three parts
// - unaligned tail, after the last word aligned address in text
// - body, scan by 2 words at a time
// - the first remaining bytes, < 2 word size
let len = text.len();
let ptr = text.as_ptr();
// search to an aligned boundary
let end_align = (ptr as usize + len) & (usize::BYTES - 1);
let mut offset;
if end_align > 0 {
offset = len - cmp::min(usize::BYTES - end_align, len);
if let Some(index) = text[offset..].iter().rposition(|elt| *elt == x) {
return Some(offset + index);
}
} else {
offset = len;
}
// search the body of the text
let repeated_x = repeat_byte(x);
while offset >= 2 * usize::BYTES {
unsafe {
let u = *(ptr.offset(offset as isize - 2 * usize::BYTES as isize) as *const usize);
let v = *(ptr.offset(offset as isize - usize::BYTES as isize) as *const usize);
// break if there is a matching byte
let zu = contains_zero_byte(u ^ repeated_x);
let zv = contains_zero_byte(v ^ repeated_x);
if zu || zv {
break;
}
}
offset -= 2 * usize::BYTES;
}
// find the byte before the point the body loop stopped
text[..offset].iter().rposition(|elt| *elt == x)
}
// test fallback implementations on all plattforms
#[test]
fn matches_one() {
assert_eq!(Some(0), memchr(b'a', b"a"));
}
#[test]
fn matches_begin() {
assert_eq!(Some(0), memchr(b'a', b"aaaa"));
}
#[test]
fn matches_end() {
assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
}
#[test]
fn matches_nul() {
assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
}
#[test]
fn matches_past_nul() {
assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
}
#[test]
fn no_match_empty() {
assert_eq!(None, memchr(b'a', b""));
}
#[test]
fn no_match() {
assert_eq!(None, memchr(b'a', b"xyz"));
}
#[test]
fn matches_one_reversed() {
assert_eq!(Some(0), memrchr(b'a', b"a"));
}
#[test]
fn matches_begin_reversed() {
assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
}
#[test]
fn matches_end_reversed() {
assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
}
#[test]
fn matches_nul_reversed() {
assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
}
#[test]
fn matches_past_nul_reversed() {
assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
}
#[test]
fn no_match_empty_reversed() {
assert_eq!(None, memrchr(b'a', b""));
}
#[test]
fn no_match_reversed() {
assert_eq!(None, memrchr(b'a', b"xyz"));
}
}
#[cfg(test)]
mod tests {
// test the implementations for the current plattform
use super::{memchr, memrchr};
#[test]
fn matches_one() {
assert_eq!(Some(0), memchr(b'a', b"a"));
}
#[test]
fn matches_begin() {
assert_eq!(Some(0), memchr(b'a', b"aaaa"));
}
#[test]
fn matches_end() {
assert_eq!(Some(4), memchr(b'z', b"aaaaz"));
}
#[test]
fn matches_nul() {
assert_eq!(Some(4), memchr(b'\x00', b"aaaa\x00"));
}
#[test]
fn matches_past_nul() {
assert_eq!(Some(5), memchr(b'z', b"aaaa\x00z"));
}
#[test]
fn no_match_empty() {
assert_eq!(None, memchr(b'a', b""));
}
#[test]
fn no_match() {
assert_eq!(None, memchr(b'a', b"xyz"));
}
#[test]
fn matches_one_reversed() {
assert_eq!(Some(0), memrchr(b'a', b"a"));
}
#[test]
fn matches_begin_reversed() {
assert_eq!(Some(3), memrchr(b'a', b"aaaa"));
}
#[test]
fn matches_end_reversed() {
assert_eq!(Some(0), memrchr(b'z', b"zaaaa"));
}
#[test]
fn matches_nul_reversed() {
assert_eq!(Some(4), memrchr(b'\x00', b"aaaa\x00"));
}
#[test]
fn matches_past_nul_reversed() {
assert_eq!(Some(0), memrchr(b'z', b"z\x00aaaa"));
}
#[test]
fn no_match_empty_reversed() {
assert_eq!(None, memrchr(b'a', b""));
}
#[test]
fn no_match_reversed() {
assert_eq!(None, memrchr(b'a', b"xyz"));
}
}

3
src/libstd/sys/unix/os.rs
View File

@ -22,6 +22,7 @@
use iter;
use libc::{self, c_int, c_char, c_void};
use mem;
use memchr;
use path::{self, PathBuf};
use ptr;
use slice;
@ -406,7 +407,7 @@ fn parse(input: &[u8]) -> Option<(OsString, OsString)> {
if input.is_empty() {
return None;
}
let pos = input[1..].iter().position(|&b| b == b'=').map(|p| p + 1);
let pos = memchr::memchr(b'=', &input[1..]).map(|p| p + 1);
pos.map(|p| (
OsStringExt::from_vec(input[..p].to_vec()),
OsStringExt::from_vec(input[p+1..].to_vec()),

100
src/test/run-pass/mir_trans_calls.rs Normal file
View File

@ -0,0 +1,100 @@
// Copyright 2015 The Rust Project Developers. See the COPYRIGHT
// file at the top-level directory of this distribution and at
// http://rust-lang.org/COPYRIGHT.
//
// Licensed under the Apache License, Version 2.0 <LICENSE-APACHE or
// http://www.apache.org/licenses/LICENSE-2.0> or the MIT license
// <LICENSE-MIT or http://opensource.org/licenses/MIT>, at your
// option. This file may not be copied, modified, or distributed
// except according to those terms.
#![feature(rustc_attrs)]
#[rustc_mir]
fn test1(a: isize, b: (i32, i32), c: &[i32]) -> (isize, (i32, i32), &[i32]) {
// Test passing a number of arguments including a fat pointer.
// Also returning via an out pointer
fn callee(a: isize, b: (i32, i32), c: &[i32]) -> (isize, (i32, i32), &[i32]) {
(a, b, c)
}
callee(a, b, c)
}
#[rustc_mir]
fn test2(a: isize) -> isize {
// Test passing a single argument.
// Not using out pointer.
fn callee(a: isize) -> isize {
a
}
callee(a)
}
struct Foo;
impl Foo {
fn inherent_method(&self, a: isize) -> isize { a }
}
#[rustc_mir]
fn test3(x: &Foo, a: isize) -> isize {
// Test calling inherent method
x.inherent_method(a)
}
trait Bar {
fn extension_method(&self, a: isize) -> isize { a }
}
impl Bar for Foo {}
#[rustc_mir]
fn test4(x: &Foo, a: isize) -> isize {
// Test calling extension method
x.extension_method(a)
}
#[rustc_mir]
fn test5(x: &Bar, a: isize) -> isize {
// Test calling method on trait object
x.extension_method(a)
}
#[rustc_mir]
fn test6<T: Bar>(x: &T, a: isize) -> isize {
// Test calling extension method on generic callee
x.extension_method(a)
}
trait One<T = Self> {
fn one() -> T;
}
impl One for isize {
fn one() -> isize { 1 }
}
#[rustc_mir]
fn test7() -> isize {
// Test calling trait static method
<isize as One>::one()
}
struct Two;
impl Two {
fn two() -> isize { 2 }
}
#[rustc_mir]
fn test8() -> isize {
// Test calling impl static method
Two::two()
}
fn main() {
assert_eq!(test1(1, (2, 3), &[4, 5, 6]), (1, (2, 3), &[4, 5, 6][..]));
assert_eq!(test2(98), 98);
assert_eq!(test3(&Foo, 42), 42);
assert_eq!(test4(&Foo, 970), 970);
assert_eq!(test5(&Foo, 8576), 8576);
assert_eq!(test6(&Foo, 12367), 12367);
assert_eq!(test7(), 1);
assert_eq!(test8(), 2);
}