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

auto merge of #13692 : vadimcn/rust/Win64-pre, r=alexcrichton

Browse Source 
Stack unwinding doesn't work yet, so this won't pass a lot of tests.
This commit is contained in:
bors 2014-04-23 03:21:32 -07:00
commit 1ce0b98c7b
10 changed files with 111 additions and 48 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

4
mk/rt.mk
View File

@ -247,8 +247,8 @@ $$(COMPRT_LIB_$(1)): $$(COMPRT_DEPS) $$(MKFILE_DEPS)
RANLIB="$$(AR_$(1)) s" \
CFLAGS="$$(CFG_GCCISH_CFLAGS_$(1))" \
TargetTriple=$(1) \
triple-runtime
$$(Q)cp $$(COMPRT_BUILD_DIR_$(1))/triple/runtime/libcompiler_rt.a $$(COMPRT_LIB_$(1))
triple-builtins
$$(Q)cp $$(COMPRT_BUILD_DIR_$(1))/triple/builtins/libcompiler_rt.a $$(COMPRT_LIB_$(1))
################################################################################
# libbacktrace

2
src/compiler-rt

@ -1 +1 @@
Subproject commit f4b221571ce6f05714c1f1c6fa48f1393499989c
Subproject commit ed112ca1e4275e1c5707a898f2bf6164707ba378

4
src/etc/get-snapshot.py
View File

@ -50,7 +50,9 @@ triple = sys.argv[1]
if len(sys.argv) == 3:
dl_path = sys.argv[2]
else:
snap = determine_curr_snapshot(triple)
# There are no 64-bit Windows snapshots yet, so we'll use 32-bit ones instead, for now
snap_triple = triple if triple != "x86_64-w64-mingw32" else "i686-pc-mingw32"
snap = determine_curr_snapshot(snap_triple)
dl = os.path.join(download_dir_base, snap)
url = download_url_base + "/" + snap
print("determined most recent snapshot: " + snap)

15
src/libgreen/macros.rs
View File

@ -52,20 +52,9 @@ macro_rules! rtabort (
pub fn dumb_println(args: &fmt::Arguments) {
use std::io;
use libc;
use std::rt;
struct Stderr;
impl io::Writer for Stderr {
fn write(&mut self, data: &[u8]) -> io::IoResult<()> {
unsafe {
libc::write(libc::STDERR_FILENO,
data.as_ptr() as *libc::c_void,
data.len() as libc::size_t);
}
Ok(()) // just ignore the result
}
}
let mut w = Stderr;
let mut w = rt::Stderr;
let _ = fmt::writeln(&mut w as &mut io::Writer, args);
}

15
src/librustuv/macros.rs
View File

@ -29,19 +29,8 @@ macro_rules! uvdebug (
pub fn dumb_println(args: &fmt::Arguments) {
use std::io;
use libc;
use std::rt;
struct Stderr;
impl io::Writer for Stderr {
fn write(&mut self, data: &[u8]) -> io::IoResult<()> {
let _ = unsafe {
libc::write(libc::STDERR_FILENO,
data.as_ptr() as *libc::c_void,
data.len() as libc::size_t)
};
Ok(()) // just ignore the errors
}
}
let mut w = Stderr;
let mut w = rt::Stderr;
let _ = fmt::writeln(&mut w as &mut io::Writer, args);
}

16
src/libstd/io/stdio.rs
View File

@ -27,7 +27,6 @@ out.write(bytes!("Hello, world!"));
*/
use container::Container;
use fmt;
use io::{Reader, Writer, IoResult, IoError, OtherIoError,
standard_error, EndOfFile, LineBufferedWriter, BufferedReader};
@ -37,11 +36,11 @@ use mem::replace;
use option::{Option, Some, None};
use prelude::drop;
use result::{Ok, Err};
use rt;
use rt::local::Local;
use rt::rtio::{DontClose, IoFactory, LocalIo, RtioFileStream, RtioTTY};
use rt::task::Task;
use str::StrSlice;
use slice::ImmutableVector;
// And so begins the tale of acquiring a uv handle to a stdio stream on all
// platforms in all situations. Our story begins by splitting the world into two
@ -236,18 +235,7 @@ fn with_task_stdout(f: |&mut Writer| -> IoResult<()> ) {
}
None => {
struct Stdout;
impl Writer for Stdout {
fn write(&mut self, data: &[u8]) -> IoResult<()> {
unsafe {
libc::write(libc::STDOUT_FILENO,
data.as_ptr() as *libc::c_void,
data.len() as libc::size_t);
}
Ok(()) // just ignore the results
}
}
let mut io = Stdout;
let mut io = rt::Stdout;
f(&mut io as &mut Writer)
}
};

83
src/libstd/rt/backtrace.rs
View File

@ -665,6 +665,89 @@ mod imp {
}
}
#[cfg(target_arch = "x86_64")]
mod arch {
use libc::{c_longlong, c_ulonglong};
use libc::types::os::arch::extra::{WORD, DWORD, DWORDLONG};
pub struct CONTEXT {
P1Home: DWORDLONG,
P2Home: DWORDLONG,
P3Home: DWORDLONG,
P4Home: DWORDLONG,
P5Home: DWORDLONG,
P6Home: DWORDLONG,
ContextFlags: DWORD,
MxCsr: DWORD,
SegCs: WORD,
SegDs: WORD,
SegEs: WORD,
SegFs: WORD,
SegGs: WORD,
SegSs: WORD,
EFlags: DWORD,
Dr0: DWORDLONG,
Dr1: DWORDLONG,
Dr2: DWORDLONG,
Dr3: DWORDLONG,
Dr6: DWORDLONG,
Dr7: DWORDLONG,
Rax: DWORDLONG,
Rcx: DWORDLONG,
Rdx: DWORDLONG,
Rbx: DWORDLONG,
Rsp: DWORDLONG,
Rbp: DWORDLONG,
Rsi: DWORDLONG,
Rdi: DWORDLONG,
R8: DWORDLONG,
R9: DWORDLONG,
R10: DWORDLONG,
R11: DWORDLONG,
R12: DWORDLONG,
R13: DWORDLONG,
R14: DWORDLONG,
R15: DWORDLONG,
Rip: DWORDLONG,
FltSave: FLOATING_SAVE_AREA,
VectorRegister: [M128A, .. 26],
VectorControl: DWORDLONG,
DebugControl: DWORDLONG,
LastBranchToRip: DWORDLONG,
LastBranchFromRip: DWORDLONG,
LastExceptionToRip: DWORDLONG,
LastExceptionFromRip: DWORDLONG,
}
pub struct M128A {
Low: c_ulonglong,
High: c_longlong
}
pub struct FLOATING_SAVE_AREA {
_Dummy: [u8, ..512] // FIXME: Fill this out
}
pub fn init_frame(frame: &mut super::STACKFRAME64,
ctx: &CONTEXT) -> DWORD {
frame.AddrPC.Offset = ctx.Rip as u64;
frame.AddrPC.Mode = super::AddrModeFlat;
frame.AddrStack.Offset = ctx.Rsp as u64;
frame.AddrStack.Mode = super::AddrModeFlat;
frame.AddrFrame.Offset = ctx.Rbp as u64;
frame.AddrFrame.Mode = super::AddrModeFlat;
super::IMAGE_FILE_MACHINE_AMD64
}
}
struct Cleanup {
handle: libc::HANDLE,
SymCleanup: SymCleanupFn,

2
src/libstd/rt/mod.rs
View File

@ -71,6 +71,8 @@ pub use self::util::default_sched_threads;
// Export unwinding facilities used by the failure macros
pub use self::unwind::{begin_unwind, begin_unwind_raw, begin_unwind_fmt};
pub use self::util::{Stdio, Stdout, Stderr};
// FIXME: these probably shouldn't be public...
#[doc(hidden)]
pub mod shouldnt_be_public {

16
src/libstd/rt/util.rs
View File

@ -71,14 +71,22 @@ pub fn default_sched_threads() -> uint {
}
}
pub struct Stderr;
pub struct Stdio(libc::c_int);
impl io::Writer for Stderr {
pub static Stdout: Stdio = Stdio(libc::STDOUT_FILENO);
pub static Stderr: Stdio = Stdio(libc::STDERR_FILENO);
impl io::Writer for Stdio {
fn write(&mut self, data: &[u8]) -> IoResult<()> {
#[cfg(unix)]
type WriteLen = libc::size_t;
#[cfg(windows)]
type WriteLen = libc::c_uint;
unsafe {
libc::write(libc::STDERR_FILENO,
let Stdio(fd) = *self;
libc::write(fd,
data.as_ptr() as *libc::c_void,
data.len() as libc::size_t);
data.len() as WriteLen);
}
Ok(()) // yes, we're lying
}

2
src/libstd/unstable/mutex.rs
View File

@ -444,6 +444,8 @@ mod imp {
static SPIN_COUNT: DWORD = 4000;
#[cfg(target_arch = "x86")]
static CRIT_SECTION_SIZE: uint = 24;
#[cfg(target_arch = "x86_64")]
static CRIT_SECTION_SIZE: uint = 40;
pub struct Mutex {
// pointers for the lock/cond handles, atomically updated