replace malloc with operator new

sekiguchi-nagisa · Apr 20, 2024 · c1fcf77 · c1fcf77
1 parent cb736d1
commit c1fcf77
Show file tree

Hide file tree

Showing 5 changed files with 8 additions and 38 deletions.
diff --git a/src/candidates.h b/src/candidates.h
@@ -43,15 +43,11 @@ class CandidateObject : public ObjectWithRtti<ObjectKind::Candidate> {
     assert(description.size() <= MAX_SIZE);
     assert(candidate.size() + 1 <= MAX_SIZE - description.size());
     const unsigned int allocSize = candidate.size() + description.size() + 1;
-    void *ptr = malloc(sizeof(CandidateObject) + sizeof(char) * allocSize);
+    void *ptr = operator new(sizeof(CandidateObject) + sizeof(char) * allocSize);
     auto *obj = new (ptr) CandidateObject(candidate, description);
     return ObjPtr<CandidateObject>(obj);
   }
 
-  static void operator delete(void *ptr) noexcept { // NOLINT
-    free(ptr);
-  }
-
   unsigned int candidateSize() const { return this->canSize; }
 
   unsigned int descriptionSize() const { return this->descSize; }

diff --git a/src/job.h b/src/job.h
@@ -254,7 +254,7 @@ class JobObject : public ObjectWithRtti<ObjectKind::Job> {
   static ObjPtr<JobObject> create(unsigned int size, const Proc *procs, bool saveStdin,
                                   ObjPtr<UnixFdObject> inObj, ObjPtr<UnixFdObject> outObj,
                                   Value &&desc) {
-    void *ptr = malloc(sizeof(JobObject) + sizeof(Proc) * size);
+    void *ptr = operator new(sizeof(JobObject) + sizeof(Proc) * size);
     auto *entry = new (ptr)
         JobObject(size, procs, saveStdin, std::move(inObj), std::move(outObj), std::move(desc));
     return ObjPtr<JobObject>(entry);
@@ -266,10 +266,6 @@ class JobObject : public ObjectWithRtti<ObjectKind::Job> {
     return create(1, procs, false, std::move(inObj), std::move(outObj), std::move(desc));
   }
 
-  static void operator delete(void *ptr) noexcept { // NOLINT
-    free(ptr);
-  }
-
   unsigned int getProcSize() const { return this->procSize; }
 
   State state() const { return static_cast<State>(STATE_MASK & this->meta); }

diff --git a/src/object.h b/src/object.h
@@ -939,7 +939,7 @@ class BaseObject : public ObjectWithRtti<ObjectKind::Base> {
 
 public:
   static BaseObject *create(const DSType &type, unsigned int size) {
-    void *ptr = malloc(sizeof(BaseObject) + sizeof(RawValue) * size);
+    void *ptr = operator new(sizeof(BaseObject) + sizeof(RawValue) * size);
     return new (ptr) BaseObject(type, size);
   }
 
@@ -960,11 +960,6 @@ class BaseObject : public ObjectWithRtti<ObjectKind::Base> {
     return static_cast<const Value &>(this->fields[index]);
   }
 
-  static void operator delete(void *ptr) noexcept {
-    // NOLINT
-    free(ptr);
-  }
-
   unsigned int getFieldSize() const { return this->fieldSize; }
 };
 
@@ -1286,7 +1281,7 @@ class ClosureObject : public ObjectWithRtti<ObjectKind::Closure> {
 
 public:
   static ClosureObject *create(ObjPtr<FuncObject> func, unsigned int size, const Value *values) {
-    void *ptr = malloc(sizeof(ClosureObject) + sizeof(RawValue) * size);
+    void *ptr = operator new(sizeof(ClosureObject) + sizeof(RawValue) * size);
     auto *closure = new (ptr) ClosureObject(std::move(func), size);
     for (unsigned int i = 0; i < size; i++) {
       (*closure)[i] = values[i];
@@ -1303,11 +1298,6 @@ class ClosureObject : public ObjectWithRtti<ObjectKind::Closure> {
   const Value &operator[](unsigned int index) const {
     return static_cast<const Value &>(this->upvars[index]);
   }
-
-  static void operator delete(void *ptr) noexcept {
-    // NOLINT
-    free(ptr);
-  }
 };
 
 template <typename... Arg>

diff --git a/src/type.cpp b/src/type.cpp
@@ -361,7 +361,7 @@ std::unique_ptr<MethodHandle> MethodHandle::create(const DSType &recv, unsigned
                                                    PackedParamNames &&packed, ModId modId) {
   const size_t paramSize = params.size();
   assert(paramSize <= SYS_LIMIT_METHOD_PARAM_NUM);
-  void *ptr = malloc(sizeof(MethodHandle) + sizeof(uintptr_t) * paramSize);
+  void *ptr = operator new(sizeof(MethodHandle) + sizeof(uintptr_t) * paramSize);
   const auto &actualRet = ret ? *ret : recv;
   auto *handle = new (ptr) MethodHandle(recv, index, actualRet, paramSize, modId,
                                         ret ? HandleKind::METHOD : HandleKind::CONSTRUCTOR);

diff --git a/src/type.h b/src/type.h
@@ -493,7 +493,7 @@ class FunctionType : public DSType {
 public:
   static FunctionType *create(unsigned int id, StringRef ref, const DSType &superType,
                               const DSType &returnType, std::vector<const DSType *> &&paramTypes) {
-    void *ptr = malloc(sizeof(FunctionType) + sizeof(DSType *) * paramTypes.size());
+    void *ptr = operator new(sizeof(FunctionType) + sizeof(DSType *) * paramTypes.size());
     return new (ptr) FunctionType(id, ref, superType, returnType, std::move(paramTypes));
   }
 
@@ -513,10 +513,6 @@ class FunctionType : public DSType {
             this->getParamSize() == 0 ? nullptr : &this->paramTypes[0], name, hd};
   }
 
-  static void operator delete(void *ptr) noexcept { // NOLINT
-    free(ptr);
-  }
-
   static bool classof(const DSType *type) { return type->isFuncType(); }
 };
 
@@ -956,15 +952,11 @@ class FuncHandle : public Handle {
     if (famSize) {
       famSize++; // reserve sentinel
     }
-    void *ptr = malloc(sizeof(FuncHandle) + sizeof(char) * famSize);
+    void *ptr = operator new(sizeof(FuncHandle) + sizeof(char) * famSize);
     auto *handle = new (ptr) FuncHandle(funcType, index, std::move(packed), modId);
     return std::unique_ptr<FuncHandle>(handle);
   }
 
-  static void operator delete(void *ptr) noexcept { // NOLINT
-    free(ptr);
-  }
-
   StringRef getPackedParamNames() const {
     StringRef ref;
     if (this->hasParams()) {
@@ -1021,14 +1013,10 @@ class MethodHandle : public Handle {
 
   ~MethodHandle();
 
-  static void operator delete(void *ptr) noexcept { // NOLINT
-    free(ptr);
-  }
-
   static std::unique_ptr<MethodHandle>
   native(const DSType &recv, unsigned int index, const DSType &ret, unsigned char paramSize,
          const std::array<const DSType *, HandleInfoParamNumMax()> &paramTypes) {
-    void *ptr = malloc(sizeof(MethodHandle) + sizeof(uintptr_t) * paramSize);
+    void *ptr = operator new(sizeof(MethodHandle) + sizeof(uintptr_t) * paramSize);
     auto *handle =
         new (ptr) MethodHandle(recv, index, ret, paramSize, BUILTIN_MOD_ID, HandleKind::NATIVE);
     for (unsigned int i = 0; i < static_cast<unsigned int>(paramSize); i++) {