[libc][NFC] Use operator new and operator delete in POSIX file actions API.

libc/src/spawn/CMakeLists.txt

add_entrypoint_object(
   SRCS
     posix_spawn_file_actions_destroy.cpp
   HDRS
     posix_spawn_file_actions_destroy.h
   DEPENDS
     .file_actions
     libc.include.errno
     libc.include.spawn
+    libc.src.__support.CPP.new
 )
 
 add_entrypoint_object(
   posix_spawn_file_actions_adddup2
   SRCS
     posix_spawn_file_actions_adddup2.cpp
   HDRS
     posix_spawn_file_actions_adddup2.h
   DEPENDS
     .file_actions
     libc.include.errno
     libc.include.spawn
+    libc.src.__support.CPP.new
 )
 
 add_entrypoint_object(
   posix_spawn_file_actions_addopen
   SRCS
     posix_spawn_file_actions_addopen.cpp
   HDRS
     posix_spawn_file_actions_addopen.h
   DEPENDS
     .file_actions
     libc.include.errno
     libc.include.spawn
+    libc.src.__support.CPP.new
 )
 
 add_entrypoint_object(
   posix_spawn_file_actions_addclose
   SRCS
     posix_spawn_file_actions_addclose.cpp
   HDRS
     posix_spawn_file_actions_addclose.h
   DEPENDS
     .file_actions
     libc.include.errno
     libc.include.spawn
+    libc.src.__support.CPP.new
 )
 
 add_entrypoint_object(
   posix_spawn
   ALIAS
   DEPENDS
     .${LIBC_TARGET_OS}.posix_spawn
 )

libc/src/spawn/file_actions.h

struct BaseSpawnFileAction {
   enum ActionType {
     OPEN = 111,
     CLOSE = 222,
     DUP2 = 333,
   };
 
   ActionType type;
   BaseSpawnFileAction *next;
+
+  static void add_action(posix_spawn_file_actions_t *actions,
+                         BaseSpawnFileAction *act) {
+    if (actions->__back != nullptr) {
+      auto *back = reinterpret_cast<BaseSpawnFileAction *>(actions->__back);
+      back->next = act;
+      actions->__back = act;
+    } else {
+      // First action is being added.
+      actions->__front = actions->__back = act;
+    }
+  }
+
+protected:
+  explicit BaseSpawnFileAction(ActionType t) : type(t), next(nullptr) {}
 };
 
 struct SpawnFileOpenAction : public BaseSpawnFileAction {
   const char *path;
   int fd;
   int oflag;
   mode_t mode;
+
+  SpawnFileOpenAction(const char *p, int fdesc, int flags, mode_t m)
+      : BaseSpawnFileAction(BaseSpawnFileAction::OPEN), path(p), fd(fdesc),
+        oflag(flags), mode(m) {}
 };
 
 struct SpawnFileCloseAction : public BaseSpawnFileAction {
   int fd;
+
+  SpawnFileCloseAction(int fdesc)
+      : BaseSpawnFileAction(BaseSpawnFileAction::CLOSE), fd(fdesc) {}
 };
 
 struct SpawnFileDup2Action : public BaseSpawnFileAction {
   int fd;
   int newfd;
-};
 
-inline void enque_spawn_action(posix_spawn_file_actions_t *actions,
-                               BaseSpawnFileAction *act) {
-  if (actions->__back != nullptr) {
-    auto *back = reinterpret_cast<BaseSpawnFileAction *>(actions->__back);
-    back->next = act;
-    actions->__back = act;
-  } else {
-    // First action is being added.
-    actions->__front = actions->__back = act;
-  }
-}
+  SpawnFileDup2Action(int fdesc, int new_fdesc)
+      : BaseSpawnFileAction(BaseSpawnFileAction::DUP2), fd(fdesc),
+        newfd(new_fdesc) {}
+};
 
 } // namespace __llvm_libc
 
 #endif // LLVM_LIBC_SRC_SPAWN_FILE_ACTIONS_H

libc/src/spawn/posix_spawn_file_actions_addclose.cpp

 //===-- Implementation of posix_spawn_file_actions_addclose ---------------===//
 //
 // 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 "posix_spawn_file_actions_addclose.h"
 
 #include "file_actions.h"
+#include "src/__support/CPP/new.h"
 #include "src/__support/common.h"
 
 #include <errno.h>
 #include <spawn.h>
-#include <stdlib.h> // For malloc
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, posix_spawn_file_actions_addclose,
                    (posix_spawn_file_actions_t *__restrict actions, int fd)) {
   if (actions == nullptr)
     return EINVAL;
   if (fd < 0)
     return EBADF;
 
-  auto *act = reinterpret_cast<SpawnFileCloseAction *>(
-      malloc(sizeof(SpawnFileCloseAction)));
-  if (act == nullptr)
+  AllocChecker ac;
+  auto *act = new (ac) SpawnFileCloseAction(fd);
+  if (!ac)
     return ENOMEM;
+  BaseSpawnFileAction::add_action(actions, act);
 
-  act->type = BaseSpawnFileAction::CLOSE;
-  act->fd = fd;
-  enque_spawn_action(actions, act);
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/spawn/posix_spawn_file_actions_adddup2.cpp

 //===-- Implementation of posix_spawn_file_actions_adddup2 ----------------===//
 //
 // 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 "posix_spawn_file_actions_adddup2.h"
 
 #include "file_actions.h"
+#include "src/__support/CPP/new.h"
 #include "src/__support/common.h"
 
 #include <errno.h>
 #include <spawn.h>
-#include <stdlib.h> // For malloc
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, posix_spawn_file_actions_adddup2,
                    (posix_spawn_file_actions_t * actions, int fd, int newfd)) {
   if (actions == nullptr)
     return EINVAL;
   if (fd < 0 || newfd < 0)
     return EBADF;
 
-  auto *act = reinterpret_cast<SpawnFileDup2Action *>(
-      malloc(sizeof(SpawnFileDup2Action)));
-  if (act == nullptr)
+  AllocChecker ac;
+  auto *act = new (ac) SpawnFileDup2Action(fd, newfd);
+  if (!ac)
     return ENOMEM;
+  BaseSpawnFileAction::add_action(actions, act);
 
-  act->type = BaseSpawnFileAction::DUP2;
-  act->fd = fd;
-  act->newfd = newfd;
-  act->next = nullptr;
-  enque_spawn_action(actions, act);
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/spawn/posix_spawn_file_actions_addopen.cpp

 //===-- Implementation of posix_spawn_file_actions_addopen ----------------===//
 //
 // 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 "posix_spawn_file_actions_addopen.h"
 
 #include "file_actions.h"
+#include "src/__support/CPP/new.h"
 #include "src/__support/common.h"
 
 #include <errno.h>
 #include <spawn.h>
-#include <stdlib.h> // For malloc
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, posix_spawn_file_actions_addopen,
                    (posix_spawn_file_actions_t *__restrict actions, int fd,
                     const char *__restrict path, int oflag, mode_t mode)) {
   if (actions == nullptr)
     return EINVAL;
   if (fd < 0)
     return EBADF;
 
-  auto *act = reinterpret_cast<SpawnFileOpenAction *>(
-      malloc(sizeof(SpawnFileOpenAction)));
+  AllocChecker ac;
+  auto *act = new (ac) SpawnFileOpenAction(path, fd, oflag, mode);
   if (act == nullptr)
     return ENOMEM;
+  BaseSpawnFileAction::add_action(actions, act);
 
-  act->type = BaseSpawnFileAction::OPEN;
-  act->fd = fd;
-  act->path = path;
-  act->oflag = oflag;
-  act->mode = mode;
-  act->next = nullptr;
-  enque_spawn_action(actions, act);
   return 0;
 }
 
 } // namespace __llvm_libc

libc/src/spawn/posix_spawn_file_actions_destroy.cpp

 //===-- Implementation of posix_spawn_file_actions_destroy ----------------===//
 //
 // 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 "posix_spawn_file_actions_destroy.h"
 
 #include "file_actions.h"
+#include "src/__support/CPP/new.h"
 #include "src/__support/common.h"
 
 #include <errno.h>
 #include <spawn.h>
-#include <stdlib.h> // For free
 
 namespace __llvm_libc {
 
 LLVM_LIBC_FUNCTION(int, posix_spawn_file_actions_destroy,
                    (posix_spawn_file_actions_t * actions)) {
   if (actions == nullptr)
     return EINVAL;
   if (actions->__front == nullptr)
     return 0;
 
   auto *act = reinterpret_cast<BaseSpawnFileAction *>(actions->__front);
   actions->__front = nullptr;
   actions->__back = nullptr;
+  if (act == nullptr)
+    return 0;
 
+  act = act->next;
   while (act != nullptr) {
-    auto *next = act->next;
-    free(act);
-    act = next;
+    auto *temp = act;
+    act = act->next;
+    switch (temp->type) {
+    case BaseSpawnFileAction::OPEN:
+      delete reinterpret_cast<SpawnFileOpenAction *>(temp);
+      break;
+    case BaseSpawnFileAction::CLOSE:
+      delete reinterpret_cast<SpawnFileCloseAction *>(temp);
+      break;
+    case BaseSpawnFileAction::DUP2:
+      delete reinterpret_cast<SpawnFileDup2Action *>(temp);
+      break;
+    }
   }
 
   return 0;
 }
 
 } // namespace __llvm_libc