Line data    Source code

       1              : /*-------------------------------------------------------------------------
       2              :  *
       3              :  * fe_memutils.c
       4              :  *    memory management support for frontend code
       5              :  *
       6              :  * Portions Copyright (c) 1996-2026, PostgreSQL Global Development Group
       7              :  * Portions Copyright (c) 1994, Regents of the University of California
       8              :  *
       9              :  *
      10              :  * IDENTIFICATION
      11              :  *    src/common/fe_memutils.c
      12              :  *
      13              :  *-------------------------------------------------------------------------
      14              :  */
      15              : 
      16              : #ifndef FRONTEND
      17              : #error "This file is not expected to be compiled for backend code"
      18              : #endif
      19              : 
      20              : #include "postgres_fe.h"
      21              : 
      22              : static inline void *
      23      4096142 : pg_malloc_internal(size_t size, int flags)
      24              : {
      25              :     void       *tmp;
      26              : 
      27              :     /* Avoid unportable behavior of malloc(0) */
      28      4096142 :     if (size == 0)
      29         4411 :         size = 1;
      30      4096142 :     tmp = malloc(size);
      31      4096142 :     if (tmp == NULL)
      32              :     {
      33            0 :         if ((flags & MCXT_ALLOC_NO_OOM) == 0)
      34              :         {
      35            0 :             fprintf(stderr, _("out of memory\n"));
      36            0 :             exit(EXIT_FAILURE);
      37              :         }
      38            0 :         return NULL;
      39              :     }
      40              : 
      41      4096142 :     if ((flags & MCXT_ALLOC_ZERO) != 0)
      42      5405784 :         MemSet(tmp, 0, size);
      43      4096142 :     return tmp;
      44              : }
      45              : 
      46              : void *
      47      1979198 : pg_malloc(size_t size)
      48              : {
      49      1979198 :     return pg_malloc_internal(size, 0);
      50              : }
      51              : 
      52              : void *
      53      1295657 : pg_malloc0(size_t size)
      54              : {
      55      1295657 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
      56              : }
      57              : 
      58              : void *
      59       129451 : pg_malloc_extended(size_t size, int flags)
      60              : {
      61       129451 :     return pg_malloc_internal(size, flags);
      62              : }
      63              : 
      64              : void *
      65        92573 : pg_realloc(void *ptr, size_t size)
      66              : {
      67              :     void       *tmp;
      68              : 
      69              :     /* Avoid unportable behavior of realloc(NULL, 0) */
      70        92573 :     if (ptr == NULL && size == 0)
      71            0 :         size = 1;
      72        92573 :     tmp = realloc(ptr, size);
      73        92573 :     if (!tmp)
      74              :     {
      75            0 :         fprintf(stderr, _("out of memory\n"));
      76            0 :         exit(EXIT_FAILURE);
      77              :     }
      78        92573 :     return tmp;
      79              : }
      80              : 
      81              : /*
      82              :  * "Safe" wrapper around strdup().
      83              :  */
      84              : char *
      85      7664134 : pg_strdup(const char *in)
      86              : {
      87              :     char       *tmp;
      88              : 
      89      7664134 :     if (!in)
      90              :     {
      91            0 :         fprintf(stderr,
      92            0 :                 _("cannot duplicate null pointer (internal error)\n"));
      93            0 :         exit(EXIT_FAILURE);
      94              :     }
      95      7664134 :     tmp = strdup(in);
      96      7664134 :     if (!tmp)
      97              :     {
      98            0 :         fprintf(stderr, _("out of memory\n"));
      99            0 :         exit(EXIT_FAILURE);
     100              :     }
     101      7664134 :     return tmp;
     102              : }
     103              : 
     104              : void
     105      4385095 : pg_free(void *ptr)
     106              : {
     107      4385095 :     free(ptr);
     108      4385095 : }
     109              : 
     110              : /*
     111              :  * Frontend emulation of backend memory management functions.  Useful for
     112              :  * programs that compile backend files.
     113              :  */
     114              : void *
     115       688558 : palloc(Size size)
     116              : {
     117       688558 :     return pg_malloc_internal(size, 0);
     118              : }
     119              : 
     120              : void *
     121         2948 : palloc0(Size size)
     122              : {
     123         2948 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
     124              : }
     125              : 
     126              : void *
     127          330 : palloc_extended(Size size, int flags)
     128              : {
     129          330 :     return pg_malloc_internal(size, flags);
     130              : }
     131              : 
     132              : void
     133      2186826 : pfree(void *pointer)
     134              : {
     135      2186826 :     pg_free(pointer);
     136      2186826 : }
     137              : 
     138              : char *
     139      1183043 : pstrdup(const char *in)
     140              : {
     141      1183043 :     return pg_strdup(in);
     142              : }
     143              : 
     144              : char *
     145          146 : pnstrdup(const char *in, Size size)
     146              : {
     147              :     char       *tmp;
     148              :     int         len;
     149              : 
     150          146 :     if (!in)
     151              :     {
     152            0 :         fprintf(stderr,
     153            0 :                 _("cannot duplicate null pointer (internal error)\n"));
     154            0 :         exit(EXIT_FAILURE);
     155              :     }
     156              : 
     157          146 :     len = strnlen(in, size);
     158          146 :     tmp = malloc(len + 1);
     159          146 :     if (tmp == NULL)
     160              :     {
     161            0 :         fprintf(stderr, _("out of memory\n"));
     162            0 :         exit(EXIT_FAILURE);
     163              :     }
     164              : 
     165          146 :     memcpy(tmp, in, len);
     166          146 :     tmp[len] = '\0';
     167              : 
     168          146 :     return tmp;
     169              : }
     170              : 
     171              : void *
     172        58212 : repalloc(void *pointer, Size size)
     173              : {
     174        58212 :     return pg_realloc(pointer, size);
     175              : }