malloc.cpp

Go to the documentation of this file.

/*
 * This file is part of the µOS++ distribution.
 *   (https://github.com/micro-os-plus)
 * Copyright (c) 2016-2023 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__) */