malloc.cpp

Go to the documentation of this file.

/*
 * This file is part of the µOS++ project (https://micro-os-plus.github.io/).
 * Copyright (c) 2016-2025 Liviu Ionescu. All rights reserved.
 *
 * Permission to use, copy, modify, and/or distribute this software
 * for any purpose is hereby granted, under the terms of the MIT license.
 *
 * If a copy of the license was not distributed with this file, it can
 * be obtained from https://opensource.org/licenses/mit.
 */
 
#if defined(__ARM_EABI__) || defined(__DOXYGEN__)
 
// ----------------------------------------------------------------------------
 
#if defined(OS_USE_OS_APP_CONFIG_H)
#include <cmsis-plus/os-app-config.h>
#endif
 
#include <cmsis-plus/rtos/os.h>
#include <cmsis-plus/estd/memory_resource>
 
#include <malloc.h>
 
// ----------------------------------------------------------------------------
 
using namespace os;
 
// ----------------------------------------------------------------------------
 
// These library functions were modified to use the application
// memory resource and to be thread safe.
void*
malloc (size_t bytes)
{
  assert (!rtos::interrupts::in_handler_mode ());
 
  void* mem;
  {
    // ----- Begin of critical section --------------------------------------
    rtos::scheduler::critical_section scs;
 
    errno = 0;
    mem = estd::pmr::get_default_resource ()->allocate (bytes);
    if (mem == nullptr)
      {
        errno = ENOMEM;
      }
 
#if defined(OS_TRACE_LIBC_MALLOC)
    trace::printf ("::%s(%d)=%p\n", __func__, bytes, mem);
#endif
    // ----- End of critical section ----------------------------------------
  }
 
  return mem;
}
 
void*
calloc (size_t nelem, size_t elbytes)
{
  assert (!rtos::interrupts::in_handler_mode ());
 
  errno = 0;
  if (nelem == 0 || elbytes == 0)
    {
      return nullptr;
    }
 
  void* mem;
  {
    // ----- Begin of critical section ----------------------------------------
    rtos::scheduler::critical_section scs;
 
    mem = estd::pmr::get_default_resource ()->allocate (nelem * elbytes);
 
#if defined(OS_TRACE_LIBC_MALLOC)
    trace::printf ("::%s(%u,%u)=%p\n", __func__, nelem, elbytes, mem);
#endif
    // ----- End of critical section ------------------------------------------
  }
 
  if (mem != nullptr)
    {
      memset (mem, 0, nelem * elbytes);
    }
  else
    {
      errno = ENOMEM;
    }
 
  return mem;
}
 
void*
realloc (void* ptr, size_t bytes)
{
  assert (!rtos::interrupts::in_handler_mode ());
 
  void* mem;
 
  {
    // ----- Begin of critical section ----------------------------------------
    rtos::scheduler::critical_section scs;
 
    errno = 0;
    if (ptr == nullptr)
      {
        mem = estd::pmr::get_default_resource ()->allocate (bytes);
#if defined(OS_TRACE_LIBC_MALLOC)
        trace::printf ("::%s(%p,%u)=%p\n", __func__, ptr, bytes, mem);
#endif
        if (mem == nullptr)
          {
            errno = ENOMEM;
          }
        return mem;
      }
 
    if (bytes == 0)
      {
        estd::pmr::get_default_resource ()->deallocate (ptr, 0);
#if defined(OS_TRACE_LIBC_MALLOC)
        trace::printf ("::%s(%p,%u)=0\n", __func__, ptr, bytes);
#endif
        return nullptr;
      }
 
#if 0
      /* TODO: There is chance to shrink the chunk if newly requested
       * size is much small */
      if (nano_malloc_usable_size (RCALL ptr) >= bytes)
      return ptr;
#endif
 
    mem = estd::pmr::get_default_resource ()->allocate (bytes);
    if (mem != nullptr)
      {
        memcpy (mem, ptr, bytes);
        estd::pmr::get_default_resource ()->deallocate (ptr, 0);
      }
    else
      {
        errno = ENOMEM;
      }
 
#if defined(OS_TRACE_LIBC_MALLOC)
    trace::printf ("::%s(%p,%u)=%p", __func__, ptr, bytes, mem);
#endif
    // ----- End of critical section ------------------------------------------
  }
 
  return mem;
}
 
void
free (void* ptr)
{
  assert (!rtos::interrupts::in_handler_mode ());
 
  if (ptr == nullptr)
    {
      return;
    }
 
  // ----- Begin of critical section ------------------------------------------
  rtos::scheduler::critical_section scs;
 
#if defined(OS_TRACE_LIBC_MALLOC)
  trace::printf ("::%s(%p)\n", __func__, ptr);
#endif
 
  // Size unknown, pass 0.
  estd::pmr::get_default_resource ()->deallocate (ptr, 0);
  // ----- End of critical section --------------------------------------------
}
 
// ----------------------------------------------------------------------------
// Redirect impure functions to the implementation, to avoid including
// weird newlib functions.
void*
_malloc_r (/* struct */ _reent* impure __attribute__ ((unused)), size_t size)
{
  return malloc (size);
}
 
void*
_calloc_r (/* struct */ _reent* impure __attribute__ ((unused)), size_t n,
           size_t elem)
{
  return calloc (n, elem);
}
 
void
_free_r (/* struct */ _reent* impure __attribute__ ((unused)), void* ptr)
{
  free (ptr);
}
 
void*
_realloc_r (/* struct */ _reent* impure __attribute__ ((unused)), void* ptr,
            size_t size)
{
  return realloc (ptr, size);
}
 
// ----------------------------------------------------------------------------
// Not really implemented, but present here to avoid including
// weird newlib functions.
#pragma GCC diagnostic push
#if defined(__clang__)
#elif defined(__GNUC__)
#pragma GCC diagnostic ignored "-Waggregate-return"
#endif
 
struct mallinfo
_mallinfo_r (/* struct */ _reent* impure __attribute__ ((unused)))
{
  abort ();
}
 
#pragma GCC diagnostic pop
 
void
_malloc_stats_r (/* struct */ _reent* impure __attribute__ ((unused)))
{
  abort ();
}
 
size_t
_malloc_usable_size_r (/* struct */ _reent* reent __attribute__ ((unused)),
                       void* ptr __attribute__ ((unused)))
{
  abort ();
}
 
int
_mallopt_r (/* struct */ _reent* impure __attribute__ ((unused)),
            int parameter_number __attribute__ ((unused)),
            int parameter_value __attribute__ ((unused)))
{
  abort ();
}
 
void*
_memalign_r (/* struct */ _reent* impure __attribute__ ((unused)),
             size_t align __attribute__ ((unused)),
             size_t s __attribute__ ((unused)))
{
  abort ();
}
 
void*
_pvalloc_r (/* struct */ _reent* impure __attribute__ ((unused)),
            size_t s __attribute__ ((unused)))
{
  abort ();
}
 
void*
_valloc_r (/* struct */ _reent* impure __attribute__ ((unused)),
           size_t s __attribute__ ((unused)))
{
  abort ();
}
 
// ----------------------------------------------------------------------------
 
#endif /* defined(__ARM_EABI__) */