LCOV - code coverage report
Current view: top level - src/common - fe_memutils.c (source / functions) Hit Total Coverage
Test: PostgreSQL 13devel Lines: 39 53 73.6 %
Date: 2019-09-19 02:07:14 Functions: 12 13 92.3 %
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-2019, 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     2344396 : pg_malloc_internal(size_t size, int flags)
      24             : {
      25             :     void       *tmp;
      26             : 
      27             :     /* Avoid unportable behavior of malloc(0) */
      28     2344396 :     if (size == 0)
      29        6460 :         size = 1;
      30     2344396 :     tmp = malloc(size);
      31     2344396 :     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     2344396 :     if ((flags & MCXT_ALLOC_ZERO) != 0)
      42     1013718 :         MemSet(tmp, 0, size);
      43     2344396 :     return tmp;
      44             : }
      45             : 
      46             : void *
      47     1136580 : pg_malloc(size_t size)
      48             : {
      49     1136580 :     return pg_malloc_internal(size, 0);
      50             : }
      51             : 
      52             : void *
      53     1013686 : pg_malloc0(size_t size)
      54             : {
      55     1013686 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
      56             : }
      57             : 
      58             : void *
      59       45554 : pg_malloc_extended(size_t size, int flags)
      60             : {
      61       45554 :     return pg_malloc_internal(size, flags);
      62             : }
      63             : 
      64             : void *
      65       27200 : pg_realloc(void *ptr, size_t size)
      66             : {
      67             :     void       *tmp;
      68             : 
      69             :     /* Avoid unportable behavior of realloc(NULL, 0) */
      70       27200 :     if (ptr == NULL && size == 0)
      71           0 :         size = 1;
      72       27200 :     tmp = realloc(ptr, size);
      73       27200 :     if (!tmp)
      74             :     {
      75           0 :         fprintf(stderr, _("out of memory\n"));
      76           0 :         exit(EXIT_FAILURE);
      77             :     }
      78       27200 :     return tmp;
      79             : }
      80             : 
      81             : /*
      82             :  * "Safe" wrapper around strdup().
      83             :  */
      84             : char *
      85     7341334 : pg_strdup(const char *in)
      86             : {
      87             :     char       *tmp;
      88             : 
      89     7341334 :     if (!in)
      90             :     {
      91           0 :         fprintf(stderr,
      92           0 :                 _("cannot duplicate null pointer (internal error)\n"));
      93           0 :         exit(EXIT_FAILURE);
      94             :     }
      95     7341334 :     tmp = strdup(in);
      96     7341334 :     if (!tmp)
      97             :     {
      98           0 :         fprintf(stderr, _("out of memory\n"));
      99           0 :         exit(EXIT_FAILURE);
     100             :     }
     101     7341334 :     return tmp;
     102             : }
     103             : 
     104             : void
     105     1495050 : pg_free(void *ptr)
     106             : {
     107     1495050 :     if (ptr != NULL)
     108      902690 :         free(ptr);
     109     1495050 : }
     110             : 
     111             : /*
     112             :  * Frontend emulation of backend memory management functions.  Useful for
     113             :  * programs that compile backend files.
     114             :  */
     115             : void *
     116      148448 : palloc(Size size)
     117             : {
     118      148448 :     return pg_malloc_internal(size, 0);
     119             : }
     120             : 
     121             : void *
     122           0 : palloc0(Size size)
     123             : {
     124           0 :     return pg_malloc_internal(size, MCXT_ALLOC_ZERO);
     125             : }
     126             : 
     127             : void *
     128         128 : palloc_extended(Size size, int flags)
     129             : {
     130         128 :     return pg_malloc_internal(size, flags);
     131             : }
     132             : 
     133             : void
     134      301888 : pfree(void *pointer)
     135             : {
     136      301888 :     pg_free(pointer);
     137      301888 : }
     138             : 
     139             : char *
     140      176848 : pstrdup(const char *in)
     141             : {
     142      176848 :     return pg_strdup(in);
     143             : }
     144             : 
     145             : void *
     146         530 : repalloc(void *pointer, Size size)
     147             : {
     148         530 :     return pg_realloc(pointer, size);
     149             : }

Generated by: LCOV version 1.13