Implement malloc and free

src/terminator/mod.rs

@@ -559,6 +559,18 @@ fn call_c_abi(
         let usize = self.tcx.types.usize;
 
         match &link_name[..] {
+            "malloc" => {
+                let size = self.value_to_primval(args[0], usize)?.to_u64()?;
+                let align = self.memory.pointer_size();
+                let ptr = self.memory.allocate(size, align)?;
+                self.write_primval(dest, PrimVal::Ptr(ptr), dest_ty)?;
+            }
+
+            "free" => {
+                let ptr = args[0].read_ptr(&self.memory)?.to_ptr()?;
+                self.memory.deallocate(ptr)?;
+            }
+
             "__rust_allocate" => {
                 let size = self.value_to_primval(args[0], usize)?.to_u64()?;
                 let align = self.value_to_primval(args[1], usize)?.to_u64()?;

tests/run-pass-fullmir/regions-mock-trans.rs

@@ -0,0 +1,61 @@
+// Copyright 2012 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.
+
+// pretty-expanded FIXME #23616
+
+#![feature(libc)]
+
+extern crate libc;
+use std::mem;
+
+struct arena(());
+
+struct Bcx<'a> {
+    fcx: &'a Fcx<'a>
+}
+
+struct Fcx<'a> {
+    arena: &'a arena,
+    ccx: &'a Ccx
+}
+
+struct Ccx {
+    x: isize
+}
+
+fn alloc<'a>(_bcx : &'a arena) -> &'a Bcx<'a> {
+    unsafe {
+        mem::transmute(libc::malloc(mem::size_of::<Bcx<'a>>()
+            as libc::size_t))
+    }
+}
+
+fn h<'a>(bcx : &'a Bcx<'a>) -> &'a Bcx<'a> {
+    return alloc(bcx.fcx.arena);
+}
+
+fn g(fcx : &Fcx) {
+    let bcx = Bcx { fcx: fcx };
+    let bcx2 = h(&bcx);
+    unsafe {
+        libc::free(mem::transmute(bcx2));
+    }
+}
+
+fn f(ccx : &Ccx) {
+    let a = arena(());
+    let fcx = Fcx { arena: &a, ccx: ccx };
+    return g(&fcx);
+}
+
+pub fn main() {
+    let ccx = Ccx { x: 0 };
+    f(&ccx);
+}