[libc] Add a simple implementation of the posix_spawn function.

[sivachandra]

Summary

The implementation currently ignores all spawn attributes. Support for
them will be added in future changes.

A simple allocator for integration tests has been added so that the
integration test for posix_spawn can use the
posix_spawn_file_actions_add* functions.

[michaelrj]

libc/src/spawn/linux/posix_spawn.cpp

24–32

this feels like it might be better as a shared utility given that it's mostly the same as unistd/linux/fork.cpp (and same for the others below)

[sivachandra]

Add a TODO about using a separate and small stack after forking.

libc/src/spawn/linux/posix_spawn.cpp

24–32

I have considered that but what I have here is only temporary. We will have to change at least fork. I have added a TODO to fork to reflect how it is to be changed.

[michaelrj]

LGTM

[sivachandra]

Fix a typo and add a missing include.

libc/cmake/modules/LLVMLibCTestRules.cmake

function(add_integration_test test_name)
   # code also has to run init_array callbacks which potentially register
   # their own atexit callbacks. So, link in exit and atexit also with all
   # integration tests.
   list(
       APPEND fq_deps_list
       libc.src.__support.threads.thread
       libc.src.stdlib.atexit
       libc.src.stdlib.exit
-      libc.src.unistd.environ)
+      libc.src.unistd.environ
+      libc.utils.IntegrationTest.test)
   list(REMOVE_DUPLICATES fq_deps_list)
 
   # We don't want memory functions to be dependencies on integration tests.
   # Memory functions should be tested using unittests. The main reason
   # however is that compiler codegen can emit calls to memory functions. So,
   # we add them explicitly to the integration test libc.a (see below). Adding
   # explicit deps on the memory functions can potentially cause duplicate
   # symbol errors.

libc/config/linux/api.td

def SysSendfileAPI : PublicAPI<"sys/sendfile.h"> {
   let Types = ["off_t", "size_t", "ssize_t"];
 }
 
 def SysUtsNameAPI : PublicAPI<"sys/utsname.h"> {
   let Types = ["struct utsname"];
 }
 
 def SpawnAPI : PublicAPI<"spawn.h"> {
-  let Types = ["mode_t", "posix_spawn_file_actions_t"];
+  let Types = ["mode_t", "pid_t", "posix_spawnattr_t", "posix_spawn_file_actions_t"];
 }

libc/config/linux/x86_64/entrypoints.txt

list(APPEND TARGET_LIBC_ENTRYPOINTS
     libc.src.signal.sigdelset
     libc.src.signal.sigaddset
     libc.src.signal.sigemptyset
     libc.src.signal.sigprocmask
     libc.src.signal.sigfillset
     libc.src.signal.signal
 
     # spawn.h entrypoints
+    libc.src.spawn.posix_spawn
     libc.src.spawn.posix_spawn_file_actions_addclose
     libc.src.spawn.posix_spawn_file_actions_adddup2
     libc.src.spawn.posix_spawn_file_actions_addopen
     libc.src.spawn.posix_spawn_file_actions_destroy
     libc.src.spawn.posix_spawn_file_actions_init
 
     # threads.h entrypoints
     libc.src.threads.call_once

libc/include/CMakeLists.txt

 
 add_gen_header(
   spawn
   DEF_FILE spawn.h.def
   GEN_HDR spawn.h
   DEPENDS
     .llvm_libc_common_h
     .llvm-libc-types.mode_t
+    .llvm-libc-types.pid_t
+    .llvm-libc-types.posix_spawnattr_t
     .llvm-libc-types.posix_spawn_file_actions_t
 )
 
 # TODO: Not all platforms will have a include/sys directory. Add the sys
 # directory and the targets for sys/*.h files conditional to the OS requiring
 # them.
 file(MAKE_DIRECTORY "sys")
 

libc/include/llvm-libc-types/CMakeLists.txt

 add_header(ino_t HDR ino_t.h)
 add_header(mode_t HDR mode_t.h)
 add_header(mtx_t HDR mtx_t.h DEPENDS .__futex_word .__mutex_type)
 add_header(nlink_t HDR nlink_t.h)
 add_header(off_t HDR off_t.h)
 add_header(once_flag HDR once_flag.h DEPENDS .__futex_word)
 add_header(pid_t HDR pid_t.h)
 add_header(posix_spawn_file_actions_t HDR posix_spawn_file_actions_t.h)
+add_header(posix_spawnattr_t HDR posix_spawnattr_t.h)
 add_header(pthread_attr_t HDR pthread_attr_t.h DEPENDS .size_t)
 add_header(pthread_key_t HDR pthread_key_t.h)
 add_header(pthread_mutex_t HDR pthread_mutex_t.h DEPENDS .__futex_word .__mutex_type)
 add_header(pthread_t HDR pthread_t.h DEPENDS .__thread_type)
 add_header(pthread_mutexattr_t HDR pthread_mutexattr_t.h)
 add_header(pthread_once_t HDR pthread_once_t.h DEPENDS .__futex_word)
 add_header(rlim_t HDR rlim_t.h)
 add_header(time_t HDR time_t.h)

libc/include/llvm-libc-types/posix_spawnattr_t.h

+//===-- Definition of type posix_spawn_file_actions_t ---------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef __LLVM_LIBC_TYPES_POSIX_SPAWNATTR_T_H
+#define __LLVM_LIBC_TYPES_POSIX_SPAWNATTR_T_H
+
+typedef struct {
+  // This data structure will be populated as required.
+} posix_spawnattr_t;
+
+#endif // __LLVM_LIBC_TYPES_POSIX_SPAWNATTR_T_H

libc/spec/posix.td

 
 def ExecArgvT : NamedType<"__exec_argv_t">;
 def ExecEnvpT : NamedType<"__exec_envp_t">;
 
 def AtForkCallbackT : NamedType<"__atfork_callback_t">;
 
 def PosixSpawnFileActionsT : NamedType<"posix_spawn_file_actions_t">;
 def PosixSpawnFileActionsTPtr : PtrType<PosixSpawnFileActionsT>;
+def ConstPosixSpawnFileActionsTPtr : ConstType<PosixSpawnFileActionsTPtr>;
 def PosixSpawnFileActionsTRestrictedPtr : RestrictedPtrType<PosixSpawnFileActionsT>;
 
+def PosixSpawnAttrT : NamedType<"posix_spawnattr_t">;
+def RestrictedPosixSpawnAttrTPtrType : RestrictedPtrType<PosixSpawnAttrT>;
+
 def POSIX : StandardSpec<"POSIX"> {
   PtrType CharPtr = PtrType<CharType>;
   RestrictedPtrType RestrictedCharPtr = RestrictedPtrType<CharType>;
   RestrictedPtrType CharRestrictedDoublePtr = RestrictedPtrType<CharPtr>;
   ConstType ConstCharPtr = ConstType<CharPtr>;
   ConstType ConstRestrictedCharPtr = ConstType<RestrictedCharPtr>;
 
   NamedType ModeTType = NamedType<"mode_t">;
HeaderSpec SysIOctl = HeaderSpec<
     [], // Types
     [], // Enumerations
     []  // Functions
   >;
 
   HeaderSpec Spawn = HeaderSpec<
     "spawn.h",
     [], // Macros
-    [PosixSpawnFileActionsT, ModeTType],
+    [ModeTType, PosixSpawnAttrT, PidT, PosixSpawnFileActionsT],
     [], // Enumerations
     [
       FunctionSpec<
         "posix_spawn_file_actions_addclose",
         RetValSpec<IntType>,
         [ArgSpec<PosixSpawnFileActionsTPtr>, ArgSpec<IntType>]
       >,
       FunctionSpec<
[
         RetValSpec<IntType>,
         [ArgSpec<PosixSpawnFileActionsTPtr>]
       >,
       FunctionSpec<
         "posix_spawn_file_actions_init",
         RetValSpec<IntType>,
         [ArgSpec<PosixSpawnFileActionsTPtr>]
       >,
+      FunctionSpec<
+        "posix_spawn",
+        RetValSpec<IntType>,
+        [ArgSpec<RestrictedPidTPtr>, ArgSpec<ConstCharRestrictedPtr>,
+         ArgSpec<PosixSpawnFileActionsTPtr>, ArgSpec<RestrictedPosixSpawnAttrTPtrType>,
+         ArgSpec<ConstCharRestrictedPtrPtr>, ArgSpec<ConstCharRestrictedPtrPtr>]
+      >,
     ]
   >;
 
   let Headers = [
     CType,
     Dirent,
     Errno,
     FCntl,

libc/spec/spec.td

 def VoidRestrictedPtr : RestrictedPtrType<VoidType>;
 def ConstVoidRestrictedPtr : ConstType<VoidRestrictedPtr>;
 
 def CharPtr : PtrType<CharType>;
 def ConstCharPtr : ConstType<CharPtr>;
 def CharRestrictedPtr : RestrictedPtrType<CharType>;
 def CharRestrictedPtrPtr : RestrictedPtrType<CharPtr>;
 def ConstCharRestrictedPtr : ConstType<CharRestrictedPtr>;
+def ConstCharRestrictedPtrPtr : PtrType<ConstCharRestrictedPtr>;
 
 def OnceFlagType : NamedType<"once_flag">;
 def OnceFlagTypePtr : PtrType<OnceFlagType>;
 // TODO(sivachandra): Remove this non-standard type when a formal
 // way to describe callable types is available.
 def CallOnceFuncType : NamedType<"__call_once_func_t">;
 def MtxTType : NamedType<"mtx_t">;
 def MtxTTypePtr : PtrType<MtxTType>;

 
 def FILE : NamedType<"FILE">;
 def FILEPtr : PtrType<FILE>;
 def FILERestrictedPtr : RestrictedPtrType<FILE>;
 
 def PThreadTType : NamedType<"pthread_t">;
 
 def PidT : NamedType<"pid_t">;
+def RestrictedPidTPtr : RestrictedPtrType<PidT>;
+
 def StructRUsage : NamedType<"struct rusage">;
 def StructRUsagePtr : PtrType<StructRUsage>;
 
 //added because __assert_fail needs it.
 def UnsignedType : NamedType<"unsigned">;
 
 class Macro<string name> {
   string Name = name;

libc/src/spawn/CMakeLists.txt

+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
+  add_subdirectory(${CMAKE_CURRENT_SOURCE_DIR}/${LIBC_TARGET_OS})
+endif()
+
 add_header_library(
   file_actions
   HDRS
     file_actions.h
   DEPENDS
     libc.include.spawn
 )
 
SRCS
     posix_spawn_file_actions_addclose.cpp
   HDRS
     posix_spawn_file_actions_addclose.h
   DEPENDS
     .file_actions
     libc.include.errno
     libc.include.spawn
 )
+
+add_entrypoint_object(
+  posix_spawn
+  ALIAS
+  DEPENDS
+    .${LIBC_TARGET_OS}.posix_spawn
+)

libc/src/spawn/linux/CMakeLists.txt

+add_entrypoint_object(
+  posix_spawn
+  SRCS
+    posix_spawn.cpp
+  HDRS
+    ../posix_spawn.h
+  DEPENDS
+    libc.include.fcntl
+    libc.include.spawn
+    libc.include.sys_syscall
+    libc.src.__support.CPP.optional
+    libc.src.__support.OSUtil.osutil
+    libc.src.spawn.file_actions
+)

libc/src/spawn/linux/posix_spawn.cpp

+//===-- Linux implementation of posix_spawn -------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "src/spawn/posix_spawn.h"
+
+#include "src/__support/CPP/optional.h"
+#include "src/__support/OSUtil/syscall.h" // For internal syscall function.
+#include "src/__support/common.h"
+#include "src/spawn/file_actions.h"
+
+#include <fcntl.h>
+#include <spawn.h>
+#include <sys/syscall.h> // For syscall numbers.
+
+namespace __llvm_libc {
+
+namespace {
+
+pid_t fork() {
+  // TODO: Use only the clone syscall and use a sperate small stack in the child
+  // to avoid duplicating the complete stack from the parent. A new stack will
+  // be created on exec anyway so duplicating the full stack is unnecessary.
+#ifdef SYS_fork
+  return __llvm_libc::syscall_impl(SYS_fork);
+#elif defined(SYS_clone)
+  return __llvm_libc::syscall_impl(SYS_clone, SIGCHLD, 0);
+#else
+#error "SYS_fork or SYS_clone not available."
+#endif
+}
+
+cpp::optional<int> open(const char *path, int oflags, mode_t mode) {
+#ifdef SYS_open
+  int fd = __llvm_libc::syscall_impl(SYS_open, path, oflags, mode);
+#else
+  int fd = __llvm_libc::syscall_impl(SYS_openat, AT_FDCWD, path, oflags, mode);
+#endif
+  if (fd > 0)
+    return fd;
+  // The open function is called as part of the child process' preparatory
+  // steps. If an open fails, the child process just exits. So, unlike
+  // the public open function, we do not need to set errno here.
+  return cpp::nullopt;
+}
+
+void close(int fd) { __llvm_libc::syscall_impl(SYS_close, fd); }
+
+bool dup2(int fd, int newfd) {
+  long ret = __llvm_libc::syscall_impl(SYS_dup2, fd, newfd);
+  return ret < 0 ? false : true;
+}
+
+// All exits from child_process are error exits. So, we use a simple
+// exit implementation which exits with code 127.
+void exit() {
+  for (;;) {
+    __llvm_libc::syscall_impl(SYS_exit_group, 127);
+    __llvm_libc::syscall_impl(SYS_exit, 127);
+  }
+}
+
+void child_process(const char *__restrict path,
+                   const posix_spawn_file_actions_t *file_actions,
+                   const posix_spawnattr_t *__restrict, // For now unused
+                   char *const *__restrict argv, char *const *__restrict envp) {
+  // TODO: In the code below, the child_process just exits on error during
+  // processing |file_actions| and |attr|. The correct way would be to exit
+  // after conveying the information about the failure to the parent process
+  // (via a pipe for example).
+  // TODO: Handle |attr|.
+
+  if (file_actions != nullptr) {
+    auto *act = reinterpret_cast<BaseSpawnFileAction *>(file_actions->__front);
+    while (act != nullptr) {
+      switch (act->type) {
+      case BaseSpawnFileAction::OPEN: {
+        auto *open_act = reinterpret_cast<SpawnFileOpenAction *>(act);
+        auto fd = open(open_act->path, open_act->oflag, open_act->mode);
+        if (!fd)
+          exit();
+        int actual_fd = *fd;
+        if (actual_fd != open_act->fd) {
+          bool dup2_result = dup2(actual_fd, open_act->fd);
+          close(actual_fd); // The old fd is not needed anymore.
+          if (!dup2_result)
+            exit();
+        }
+        break;
+      }
+      case BaseSpawnFileAction::CLOSE: {
+        auto *close_act = reinterpret_cast<SpawnFileCloseAction *>(act);
+        close(close_act->fd);
+        break;
+      }
+      case BaseSpawnFileAction::DUP2: {
+        auto *dup2_act = reinterpret_cast<SpawnFileDup2Action *>(act);
+        if (!dup2(dup2_act->fd, dup2_act->newfd))
+          exit();
+        break;
+      }
+      }
+      act = act->next;
+    }
+  }
+
+  if (__llvm_libc::syscall_impl(SYS_execve, path, argv, envp) < 0)
+    exit();
+}
+
+} // anonymous namespace
+
+LLVM_LIBC_FUNCTION(int, posix_spawn,
+                   (pid_t *__restrict pid, const char *__restrict path,
+                    const posix_spawn_file_actions_t *file_actions,
+                    const posix_spawnattr_t *__restrict attr,
+                    char *const *__restrict argv,
+                    char *const *__restrict envp)) {
+  pid_t cpid = fork();
+  if (cpid == 0)
+    child_process(path, file_actions, attr, argv, envp);
+  else if (cpid < 0)
+    return -cpid;
+
+  if (pid != nullptr)
+    *pid = cpid;
+
+  // TODO: Before returning, one should wait for the child_process to startup
+  // successfully. For now, we will just return. Future changes will add proper
+  // wait (using pipes for example).
+
+  return 0;
+}
+
+} // namespace __llvm_libc

libc/src/spawn/posix_spawn.h

+//===-- Implementation header for posix_spawn -------------------*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_H
+#define LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_H
+
+#include <spawn.h>
+
+namespace __llvm_libc {
+
+int posix_spawn(pid_t *__restrict pid, const char *__restrict path,
+                const posix_spawn_file_actions_t *file_actions,
+                const posix_spawnattr_t *__restrict attr,
+                char *const *__restrict argv, char *const *__restrict envp);
+
+} // namespace __llvm_libc
+
+#endif // LLVM_LIBC_SRC_SPAWN_POSIX_SPAWN_H

libc/test/integration/src/CMakeLists.txt

 add_subdirectory(__support)
 add_subdirectory(pthread)
+add_subdirectory(spawn)
 add_subdirectory(stdio)
 add_subdirectory(stdlib)
 add_subdirectory(threads)
 add_subdirectory(unistd)

libc/test/integration/src/spawn/CMakeLists.txt

+add_custom_target(spawn-integration-tests)
+add_dependencies(libc-integration-tests spawn-integration-tests)
+
+add_executable(
+  libc_posix_spawn_test_binary
+  EXCLUDE_FROM_ALL
+  posix_spawn_test_binary.cpp
+  test_binary_properties.h
+)
+set_target_properties(
+  libc_posix_spawn_test_binary
+  PROPERTIES
+    OUTPUT_NAME libc_posix_spawn_test_binary
+    RUNTIME_OUTPUT_DIRECTORY ${CMAKE_CURRENT_BINARY_DIR}
+)
+
+add_header_library(
+  test_binary_properties
+  HDRS
+    test_binary_properties.h
+)
+
+add_integration_test(
+  posix_spawn_test
+  SUITE
+    spawn-integration-tests
+  SRCS
+    posix_spawn_test.cpp
+  LOADER
+    libc.loader.linux.crt1
+  DEPENDS
+    libc_posix_spawn_test_binary
+    libc.test.integration.src.spawn.test_binary_properties
+    libc.include.fcntl
+    libc.include.signal
+    libc.include.spawn
+    libc.include.sys_wait
+    libc.src.signal.raise
+    libc.src.spawn.posix_spawn
+    libc.src.spawn.posix_spawn_file_actions_addopen
+    libc.src.spawn.posix_spawn_file_actions_destroy
+    libc.src.spawn.posix_spawn_file_actions_init
+    libc.src.sys.wait.waitpid
+)
+
+add_subdirectory(testdata)

libc/test/integration/src/spawn/posix_spawn_test.cpp

+//===-- Unittests for posix_spawn -----------------------------------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include "test_binary_properties.h"
+
+#include "src/spawn/posix_spawn.h"
+#include "src/spawn/posix_spawn_file_actions_addopen.h"
+#include "src/spawn/posix_spawn_file_actions_destroy.h"
+#include "src/spawn/posix_spawn_file_actions_init.h"
+#include "src/sys/wait/waitpid.h"
+#include "utils/IntegrationTest/test.h"
+
+#include <fcntl.h>
+#include <spawn.h>
+#include <stddef.h>
+#include <stdint.h>
+#include <sys/wait.h>
+
+char arg0[] = "libc_posix_spawn_test_binary";
+char *argv[] = {
+    arg0,
+    nullptr,
+};
+
+void spawn_and_wait_for_normal_exit(char **envp) {
+  pid_t cpid;
+  posix_spawn_file_actions_t file_actions;
+  ASSERT_EQ(__llvm_libc::posix_spawn_file_actions_init(&file_actions), 0);
+  __llvm_libc::posix_spawn_file_actions_addopen(
+      &file_actions, CHILD_FD, "testdata/posix_spawn.test", O_RDONLY, 0);
+  ASSERT_EQ(
+      __llvm_libc::posix_spawn(&cpid, arg0, &file_actions, nullptr, argv, envp),
+      0);
+  ASSERT_TRUE(cpid > 0);
+  int status;
+  ASSERT_EQ(__llvm_libc::waitpid(cpid, &status, 0), cpid);
+  ASSERT_EQ(__llvm_libc::posix_spawn_file_actions_destroy(&file_actions), 0);
+  ASSERT_TRUE(WIFEXITED(status));
+  int exit_status = WEXITSTATUS(status);
+  ASSERT_EQ(exit_status, 0);
+}
+
+TEST_MAIN(int argc, char **argv, char **envp) {
+  spawn_and_wait_for_normal_exit(envp);
+  return 0;
+}

libc/test/integration/src/spawn/posix_spawn_test_binary.cpp

+#include "test_binary_properties.h"
+#include <errno.h>
+#include <string.h>
+#include <unistd.h>
+
+int main(int argc, char **argv) {
+  if (argc != 1)
+    return 5;
+  constexpr size_t bufsize = sizeof(TEXT);
+  char buf[bufsize];
+  ssize_t readsize = bufsize - 1;
+  ssize_t len = read(CHILD_FD, buf, readsize);
+  if (len != readsize) {
+    return 1;
+  }
+  buf[readsize] = '\0'; // Null terminator
+  if (close(CHILD_FD) != 0)
+    return 2;
+  if (strcmp(buf, TEXT) != 0)
+    return 3;
+  return 0;
+}

libc/test/integration/src/spawn/test_binary_properties.h

+//===-- Common definitions shared between test binary and test --*- C++ -*-===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#ifndef LIBC_TEST_INTEGRATION_SRC_SPAWN_TEST_BINARY_PROPERTIES_H
+#define LIBC_TEST_INTEGRATION_SRC_SPAWN_TEST_BINARY_PROPERTIES_H
+
+constexpr int CHILD_FD = 10;
+constexpr char TEXT[] = "Hello, posix_spawn";
+
+#endif // LIBC_TEST_INTEGRATION_SRC_SPAWN_TEST_BINARY_PROPERTIES_H

libc/test/integration/src/spawn/testdata/CMakeLists.txt

+file(GENERATE OUTPUT posix_spawn.test CONTENT "Hello, posix_spawn")

libc/utils/IntegrationTest/CMakeLists.txt

-add_header_library(
+add_object_library(
   test
+  SRCS
+    test.cpp
   HDRS
     test.h
   DEPENDS
     libc.src.__support.OSUtil.osutil
 )

libc/utils/IntegrationTest/test.cpp

+//===-- Simple malloc and free for use with integration tests -------------===//
+//
+// Part of the LLVM Project, under the Apache License v2.0 with LLVM Exceptions.
+// See https://llvm.org/LICENSE.txt for license information.
+// SPDX-License-Identifier: Apache-2.0 WITH LLVM-exception
+//
+//===----------------------------------------------------------------------===//
+
+#include <stddef.h>
+#include <stdint.h>
+
+// Integration tests cannot use the SCUDO standalone allocator as SCUDO pulls
+// various other parts of the libc. Since SCUDO development does not use
+// LLVM libc build rules, it is very hard to keep track or pull all that SCUDO
+// requires. Hence, as a work around for this problem, we use a simple allocator
+// which just hands out continuous blocks from a statically allocated chunk of
+// memory.
+
+static uint8_t memory[16384];
+static uint8_t *ptr = memory;
+
+extern "C" {
+
+void *malloc(size_t s) {
+  void *mem = ptr;
+  ptr += s;
+  return mem;
+}
+
+void free(void *) {}
+
+} // extern "C"