LCOV - code coverage report
Current view: top level - src/common - fe_memutils.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13beta1 Lines: 49 66 74.2 %
Date: 2020-06-03 11:07:14 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-2020, 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     3031212 : pg_malloc_internal(size_t size, int flags)
      24             : {
      25             :     void       *tmp;
      26             : 
      27             :     /* Avoid unportable behavior of malloc(0) */
      28     3031212 :     if (size == 0)
      29        6834 :         size = 1;
      30     3031212 :     tmp = malloc(size);
      31     3031212 :     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     3031212 :     if ((flags & MCXT_ALLOC_ZERO) != 0)
      42     3493144 :         MemSet(tmp, 0, size);
      43     3031212 :     return tmp;
      44             : }
      45             : 
      46             : void *
      47     1234674 : pg_malloc(size_t size)
      48             : {
      49     1234674 :     return pg_malloc_internal(size, 0);
      50             : }
      51             : 
      52             : void *
      53     1087440 : pg_malloc0(size_t size)
      54             : {
      55     1087440 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
      56             : }
      57             : 
      58             : void *
      59       55090 : pg_malloc_extended(size_t size, int flags)
      60             : {
      61       55090 :     return pg_malloc_internal(size, flags);
      62             : }
      63             : 
      64             : void *
      65       28886 : pg_realloc(void *ptr, size_t size)
      66             : {
      67             :     void       *tmp;
      68             : 
      69             :     /* Avoid unportable behavior of realloc(NULL, 0) */
      70       28886 :     if (ptr == NULL && size == 0)
      71           0 :         size = 1;
      72       28886 :     tmp = realloc(ptr, size);
      73       28886 :     if (!tmp)
      74             :     {
      75           0 :         fprintf(stderr, _("out of memory\n"));
      76           0 :         exit(EXIT_FAILURE);
      77             :     }
      78       28886 :     return tmp;
      79             : }
      80             : 
      81             : /*
      82             :  * "Safe" wrapper around strdup().
      83             :  */
      84             : char *
      85    10001360 : pg_strdup(const char *in)
      86             : {
      87             :     char       *tmp;
      88             : 
      89    10001360 :     if (!in)
      90             :     {
      91           0 :         fprintf(stderr,
      92           0 :                 _("cannot duplicate null pointer (internal error)\n"));
      93           0 :         exit(EXIT_FAILURE);
      94             :     }
      95    10001360 :     tmp = strdup(in);
      96    10001360 :     if (!tmp)
      97             :     {
      98           0 :         fprintf(stderr, _("out of memory\n"));
      99           0 :         exit(EXIT_FAILURE);
     100             :     }
     101    10001360 :     return tmp;
     102             : }
     103             : 
     104             : void
     105     2233682 : pg_free(void *ptr)
     106             : {
     107     2233682 :     if (ptr != NULL)
     108     1597346 :         free(ptr);
     109     2233682 : }
     110             : 
     111             : /*
     112             :  * Frontend emulation of backend memory management functions.  Useful for
     113             :  * programs that compile backend files.
     114             :  */
     115             : void *
     116      653418 : palloc(Size size)
     117             : {
     118      653418 :     return pg_malloc_internal(size, 0);
     119             : }
     120             : 
     121             : void *
     122         142 : palloc0(Size size)
     123             : {
     124         142 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
     125             : }
     126             : 
     127             : void *
     128         448 : palloc_extended(Size size, int flags)
     129             : {
     130         448 :     return pg_malloc_internal(size, flags);
     131             : }
     132             : 
     133             : void
     134      953130 : pfree(void *pointer)
     135             : {
     136      953130 :     pg_free(pointer);
     137      953130 : }
     138             : 
     139             : char *
     140      877000 : pstrdup(const char *in)
     141             : {
     142      877000 :     return pg_strdup(in);
     143             : }
     144             : 
     145             : char *
     146         162 : pnstrdup(const char *in, Size size)
     147             : {
     148             :     char       *tmp;
     149             :     int         len;
     150             : 
     151         162 :     if (!in)
     152             :     {
     153           0 :         fprintf(stderr,
     154           0 :                 _("cannot duplicate null pointer (internal error)\n"));
     155           0 :         exit(EXIT_FAILURE);
     156             :     }
     157             : 
     158         162 :     len = strnlen(in, size);
     159         162 :     tmp = malloc(len + 1);
     160         162 :     if (tmp == NULL)
     161             :     {
     162           0 :         fprintf(stderr, _("out of memory\n"));
     163           0 :         exit(EXIT_FAILURE);
     164             :     }
     165             : 
     166         162 :     memcpy(tmp, in, len);
     167         162 :     tmp[len] = '\0';
     168             : 
     169         162 :     return tmp;
     170             : }
     171             : 
     172             : void *
     173         544 : repalloc(void *pointer, Size size)
     174             : {
     175         544 :     return pg_realloc(pointer, size);
     176             : }

Generated by: LCOV version 1.13