c3a5d6b130
This commit applies a few code size optimizations for the wasm target to the standard library, namely around panics. We notably know that in most configurations it's impossible for us to print anything in wasm32-unknown-unknown so we can skip larger portions of panicking that are otherwise simply informative. This allows us to get quite a nice size reduction. Finally we can also tweak where the allocation happens for the `Box<Any>` that we panic with. By only allocating once unwinding starts we can reduce the size of a panicking wasm module from 44k to 350 bytes.
82 lines
2.1 KiB
Rust
82 lines
2.1 KiB
Rust
// 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.
|
|
|
|
use io;
|
|
use libc;
|
|
use sys::fd::FileDesc;
|
|
|
|
pub struct Stdin(());
|
|
pub struct Stdout(());
|
|
pub struct Stderr(());
|
|
|
|
impl Stdin {
|
|
pub fn new() -> io::Result<Stdin> { Ok(Stdin(())) }
|
|
|
|
pub fn read(&self, data: &mut [u8]) -> io::Result<usize> {
|
|
let fd = FileDesc::new(libc::STDIN_FILENO);
|
|
let ret = fd.read(data);
|
|
fd.into_raw();
|
|
ret
|
|
}
|
|
}
|
|
|
|
impl Stdout {
|
|
pub fn new() -> io::Result<Stdout> { Ok(Stdout(())) }
|
|
|
|
pub fn write(&self, data: &[u8]) -> io::Result<usize> {
|
|
let fd = FileDesc::new(libc::STDOUT_FILENO);
|
|
let ret = fd.write(data);
|
|
fd.into_raw();
|
|
ret
|
|
}
|
|
|
|
pub fn flush(&self) -> io::Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
impl Stderr {
|
|
pub fn new() -> io::Result<Stderr> { Ok(Stderr(())) }
|
|
|
|
pub fn write(&self, data: &[u8]) -> io::Result<usize> {
|
|
let fd = FileDesc::new(libc::STDERR_FILENO);
|
|
let ret = fd.write(data);
|
|
fd.into_raw();
|
|
ret
|
|
}
|
|
|
|
pub fn flush(&self) -> io::Result<()> {
|
|
Ok(())
|
|
}
|
|
}
|
|
|
|
// FIXME: right now this raw stderr handle is used in a few places because
|
|
// std::io::stderr_raw isn't exposed, but once that's exposed this impl
|
|
// should go away
|
|
impl io::Write for Stderr {
|
|
fn write(&mut self, data: &[u8]) -> io::Result<usize> {
|
|
Stderr::write(self, data)
|
|
}
|
|
|
|
fn flush(&mut self) -> io::Result<()> {
|
|
Stderr::flush(self)
|
|
}
|
|
}
|
|
|
|
pub fn is_ebadf(err: &io::Error) -> bool {
|
|
err.raw_os_error() == Some(libc::EBADF as i32)
|
|
}
|
|
|
|
pub const STDIN_BUF_SIZE: usize = ::sys_common::io::DEFAULT_BUF_SIZE;
|
|
|
|
pub fn stderr_prints_nothing() -> bool {
|
|
false
|
|
}
|