LCOV - code coverage report
Current view: top level - src/common - fe_memutils.c (source / functions) Hit Total Coverage
Test: PostgreSQL 18devel Lines: 48 65 73.8 %
Date: 2024-07-19 16:11:31 Functions: 14 14 100.0 %
Legend: Lines: hit not hit

          Line data    Source code
       1             : /*-------------------------------------------------------------------------
       2             :  *
       3             :  * fe_memutils.c
       4             :  *    memory management support for frontend code
       5             :  *
       6             :  * Portions Copyright (c) 1996-2024, 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     6654316 : pg_malloc_internal(size_t size, int flags)
      24             : {
      25             :     void       *tmp;
      26             : 
      27             :     /* Avoid unportable behavior of malloc(0) */
      28     6654316 :     if (size == 0)
      29        5818 :         size = 1;
      30     6654316 :     tmp = malloc(size);
      31     6654316 :     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     6654316 :     if ((flags & MCXT_ALLOC_ZERO) != 0)
      42     8437408 :         MemSet(tmp, 0, size);
      43     6654316 :     return tmp;
      44             : }
      45             : 
      46             : void *
      47     2860054 : pg_malloc(size_t size)
      48             : {
      49     2860054 :     return pg_malloc_internal(size, 0);
      50             : }
      51             : 
      52             : void *
      53     2217788 : pg_malloc0(size_t size)
      54             : {
      55     2217788 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
      56             : }
      57             : 
      58             : void *
      59      105166 : pg_malloc_extended(size_t size, int flags)
      60             : {
      61      105166 :     return pg_malloc_internal(size, flags);
      62             : }
      63             : 
      64             : void *
      65      106332 : pg_realloc(void *ptr, size_t size)
      66             : {
      67             :     void       *tmp;
      68             : 
      69             :     /* Avoid unportable behavior of realloc(NULL, 0) */
      70      106332 :     if (ptr == NULL && size == 0)
      71           0 :         size = 1;
      72      106332 :     tmp = realloc(ptr, size);
      73      106332 :     if (!tmp)
      74             :     {
      75           0 :         fprintf(stderr, _("out of memory\n"));
      76           0 :         exit(EXIT_FAILURE);
      77             :     }
      78      106332 :     return tmp;
      79             : }
      80             : 
      81             : /*
      82             :  * "Safe" wrapper around strdup().
      83             :  */
      84             : char *
      85     9990608 : pg_strdup(const char *in)
      86             : {
      87             :     char       *tmp;
      88             : 
      89     9990608 :     if (!in)
      90             :     {
      91           0 :         fprintf(stderr,
      92           0 :                 _("cannot duplicate null pointer (internal error)\n"));
      93           0 :         exit(EXIT_FAILURE);
      94             :     }
      95     9990608 :     tmp = strdup(in);
      96     9990608 :     if (!tmp)
      97             :     {
      98           0 :         fprintf(stderr, _("out of memory\n"));
      99           0 :         exit(EXIT_FAILURE);
     100             :     }
     101     9990608 :     return tmp;
     102             : }
     103             : 
     104             : void
     105     5240742 : pg_free(void *ptr)
     106             : {
     107     5240742 :     free(ptr);
     108     5240742 : }
     109             : 
     110             : /*
     111             :  * Frontend emulation of backend memory management functions.  Useful for
     112             :  * programs that compile backend files.
     113             :  */
     114             : void *
     115     1468542 : palloc(Size size)
     116             : {
     117     1468542 :     return pg_malloc_internal(size, 0);
     118             : }
     119             : 
     120             : void *
     121        2148 : palloc0(Size size)
     122             : {
     123        2148 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
     124             : }
     125             : 
     126             : void *
     127         618 : palloc_extended(Size size, int flags)
     128             : {
     129         618 :     return pg_malloc_internal(size, flags);
     130             : }
     131             : 
     132             : void
     133     2590046 : pfree(void *pointer)
     134             : {
     135     2590046 :     pg_free(pointer);
     136     2590046 : }
     137             : 
     138             : char *
     139     1596768 : pstrdup(const char *in)
     140             : {
     141     1596768 :     return pg_strdup(in);
     142             : }
     143             : 
     144             : char *
     145         322 : pnstrdup(const char *in, Size size)
     146             : {
     147             :     char       *tmp;
     148             :     int         len;
     149             : 
     150         322 :     if (!in)
     151             :     {
     152           0 :         fprintf(stderr,
     153           0 :                 _("cannot duplicate null pointer (internal error)\n"));
     154           0 :         exit(EXIT_FAILURE);
     155             :     }
     156             : 
     157         322 :     len = strnlen(in, size);
     158         322 :     tmp = malloc(len + 1);
     159         322 :     if (tmp == NULL)
     160             :     {
     161           0 :         fprintf(stderr, _("out of memory\n"));
     162           0 :         exit(EXIT_FAILURE);
     163             :     }
     164             : 
     165         322 :     memcpy(tmp, in, len);
     166         322 :     tmp[len] = '\0';
     167             : 
     168         322 :     return tmp;
     169             : }
     170             : 
     171             : void *
     172       58588 : repalloc(void *pointer, Size size)
     173             : {
     174       58588 :     return pg_realloc(pointer, size);
     175             : }

Generated by: LCOV version 1.14