mod imp {
use core::cmp;
use core::ptr;
+ use core::ptr::RawPtr;
use libc;
- use libc_heap;
use super::MIN_ALIGN;
extern {
#[inline]
pub unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
if align <= MIN_ALIGN {
- libc_heap::malloc_raw(size)
+ let ptr = libc::malloc(size as libc::size_t);
+ if ptr.is_null() {
+ ::oom();
+ }
+ ptr as *mut u8
} else {
let mut out = 0 as *mut libc::c_void;
let ret = posix_memalign(&mut out,
#[inline]
pub unsafe fn reallocate(ptr: *mut u8, old_size: uint, size: uint, align: uint) -> *mut u8 {
if align <= MIN_ALIGN {
- libc_heap::realloc_raw(ptr, size)
+ let ptr = libc::realloc(ptr as *mut libc::c_void, size as libc::size_t);
+ if ptr.is_null() {
+ ::oom();
+ }
+ ptr as *mut u8
} else {
let new_ptr = allocate(size, align);
ptr::copy_memory(new_ptr, ptr as *const u8, cmp::min(size, old_size));
mod imp {
use libc::{c_void, size_t};
use libc;
- use libc_heap;
use core::ptr::RawPtr;
use super::MIN_ALIGN;
#[inline]
pub unsafe fn allocate(size: uint, align: uint) -> *mut u8 {
if align <= MIN_ALIGN {
- libc_heap::malloc_raw(size)
+ let ptr = libc::malloc(size as size_t);
+ if ptr.is_null() {
+ ::oom();
+ }
+ ptr as *mut u8
} else {
let ptr = _aligned_malloc(size as size_t, align as size_t);
if ptr.is_null() {
#[inline]
pub unsafe fn reallocate(ptr: *mut u8, _old_size: uint, size: uint, align: uint) -> *mut u8 {
if align <= MIN_ALIGN {
- libc_heap::realloc_raw(ptr, size)
+ let ptr = libc::realloc(ptr as *mut c_void, size as size_t);
+ if ptr.is_null() {
+ ::oom();
+ }
+ ptr as *mut u8
} else {
let ptr = _aligned_realloc(ptr as *mut c_void, size as size_t,
align as size_t);
//!
//! ## Heap interfaces
//!
-//! The [`heap`](heap/index.html) and [`libc_heap`](libc_heap/index.html)
-//! modules are the unsafe interfaces to the underlying allocation systems. The
-//! `heap` module is considered the default heap, and is not necessarily backed
-//! by libc malloc/free. The `libc_heap` module is defined to be wired up to
-//! the system malloc/free.
+//! The [`heap`](heap/index.html) module defines the low-level interface to the
+//! default global allocator. It is not compatible with the libc allocator API.
#![crate_name = "alloc"]
#![experimental]
// Heaps provided for low-level allocation strategies
pub mod heap;
-pub mod libc_heap;
// Primitive types using the heaps above
+++ /dev/null
-// Copyright 2012-2014 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.
-
-
-//! The global (exchange) heap.
-
-use libc::{c_void, size_t, free, malloc, realloc};
-use core::ptr::{RawPtr, null_mut};
-
-/// A wrapper around libc::malloc, aborting on out-of-memory.
-#[inline]
-pub unsafe fn malloc_raw(size: uint) -> *mut u8 {
- // `malloc(0)` may allocate, but it may also return a null pointer
- // http://pubs.opengroup.org/onlinepubs/9699919799/functions/malloc.html
- if size == 0 {
- null_mut()
- } else {
- let p = malloc(size as size_t);
- if p.is_null() {
- ::oom();
- }
- p as *mut u8
- }
-}
-
-/// A wrapper around libc::realloc, aborting on out-of-memory.
-#[inline]
-pub unsafe fn realloc_raw(ptr: *mut u8, size: uint) -> *mut u8 {
- // `realloc(ptr, 0)` may allocate, but it may also return a null pointer
- // http://pubs.opengroup.org/onlinepubs/9699919799/functions/realloc.html
- if size == 0 {
- free(ptr as *mut c_void);
- null_mut()
- } else {
- let p = realloc(ptr as *mut c_void, size as size_t);
- if p.is_null() {
- ::oom();
- }
- p as *mut u8
- }
-}
*/
-use alloc::libc_heap::malloc_raw;
use collections::string::String;
use collections::hash;
use core::fmt;
/// with C's allocator API, rather than the usual shallow clone.
fn clone(&self) -> CString {
let len = self.len() + 1;
- let buf = unsafe { malloc_raw(len) } as *mut libc::c_char;
+ let buf = unsafe { libc::malloc(len as libc::size_t) } as *mut libc::c_char;
+ if buf.is_null() { fail!("out of memory") }
unsafe { ptr::copy_nonoverlapping_memory(buf, self.buf, len); }
CString { buf: buf as *const libc::c_char, owns_buffer_: true }
}
unsafe fn to_c_str_unchecked(&self) -> CString {
let self_len = self.len();
- let buf = malloc_raw(self_len + 1);
+ let buf = libc::malloc(self_len as libc::size_t + 1) as *mut u8;
+ if buf.is_null() { fail!("out of memory") }
ptr::copy_memory(buf, self.as_ptr(), self_len);
*buf.offset(self_len as int) = 0;
use super::CVec;
use libc;
use ptr;
- use rt::libc_heap::malloc_raw;
fn malloc(n: uint) -> CVec<u8> {
unsafe {
- let mem = malloc_raw(n);
+ let mem = libc::malloc(n as libc::size_t);
+ if mem.is_null() { fail!("out of memory") }
CVec::new_with_dtor(mem as *mut u8, n,
proc() { libc::free(mem as *mut libc::c_void); })
// Reexport functionality from librustrt and other crates underneath the
// standard library which work together to create the entire runtime.
-pub use alloc::{heap, libc_heap};
+pub use alloc::heap;
pub use rustrt::{task, local, mutex, exclusive, stack, args, rtio, thread};
pub use rustrt::{Stdio, Stdout, Stderr, begin_unwind, begin_unwind_fmt};
pub use rustrt::{bookkeeping, at_exit, unwind, DEFAULT_ERROR_CODE, Runtime};