/home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c

Bug Summary

File:	home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c
Warning:	line 1208, column 12 Potential leak of memory pointed to by 'dep_hash'
Annotated Source Code

Press '?' to see keyboard shortcuts
Show analyzer invocation
clang -cc1 -cc1 -triple x86_64-unknown-linux-gnu -analyze -disable-free -disable-llvm-verifier -discard-value-names -main-file-name concat-deps.c -analyzer-store=region -analyzer-opt-analyze-nested-blocks -analyzer-checker=core -analyzer-checker=apiModeling -analyzer-checker=unix -analyzer-checker=deadcode -analyzer-checker=security.insecureAPI.UncheckedReturn -analyzer-checker=security.insecureAPI.getpw -analyzer-checker=security.insecureAPI.gets -analyzer-checker=security.insecureAPI.mktemp -analyzer-checker=security.insecureAPI.mkstemp -analyzer-checker=security.insecureAPI.vfork -analyzer-checker=nullability.NullPassedToNonnull -analyzer-checker=nullability.NullReturnedFromNonnull -analyzer-output plist -w -setup-static-analyzer -mrelocation-model pic -pic-level 2 -mframe-pointer=none -fmath-errno -fno-rounding-math -mconstructor-aliases -munwind-tables -target-cpu x86-64 -fno-split-dwarf-inlining -debugger-tuning=gdb -resource-dir /usr/lib64/clang/11.0.0 -D BOOST_ERROR_CODE_HEADER_ONLY -D BOOST_SYSTEM_NO_DEPRECATED -D CPPU_ENV=gcc3 -D LINUX -D OSL_DEBUG_LEVEL=1 -D SAL_LOG_INFO -D SAL_LOG_WARN -D UNIX -D UNX -D X86_64 -D _PTHREADS -D _REENTRANT -D LIBO_INTERNAL_ONLY -I /home/maarten/src/libreoffice/core/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include -I /usr/lib/jvm/java-11-openjdk-11.0.9.10-0.0.ea.fc33.x86_64/include/linux -I /home/maarten/src/libreoffice/core/config_host -internal-isystem /usr/local/include -internal-isystem /usr/lib64/clang/11.0.0/include -internal-externc-isystem /include -internal-externc-isystem /usr/include -O2 -std=gnu89 -fdebug-compilation-dir /home/maarten/src/libreoffice/core -ferror-limit 19 -fvisibility hidden -stack-protector 2 -fgnuc-version=4.2.1 -vectorize-loops -vectorize-slp -debug-info-kind=constructor -analyzer-output=html -faddrsig -o /home/maarten/tmp/wis/scan-build-libreoffice/output/report/2020-10-07-141433-9725-1 -x c /home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c
1/* -*- Mode: C++; tab-width: 4; indent-tabs-mode: nil; c-basic-offset: 4 -*- */
2/*
*    Copyright (C) 2011 Norbert Thiebaud
*    License: GPLv3
*/

7/* define to activate stats reporting on hash usage*/
8/* #define HASH_STAT */

10/* ===============================================
* Set-up: defines to identify the system and system related properties
* ===============================================
*/

15#ifdef __APPLE__
16#ifdef __x86_64__1
17#undef CORE_BIG_ENDIAN
18#define CORE_LITTLE_ENDIAN
19#else
20#define CORE_BIG_ENDIAN
21#undef CORE_LITTLE_ENDIAN
22#endif

24#endif
25#ifdef _AIX
26#define CORE_BIG_ENDIAN
27#undef CORE_LITTLE_ENDIAN
28#endif /* Def _AIX */

30#ifdef _MSC_VER
31#undef CORE_BIG_ENDIAN
32#define CORE_LITTLE_ENDIAN
33#endif /* Def _MSC_VER */

35#if defined(__linux1) || defined(__FreeBSD_kernel__)
36#include <sys/param.h>
37#if __BYTE_ORDER1234 == __LITTLE_ENDIAN1234
38#undef CORE_BIG_ENDIAN
39#define CORE_LITTLE_ENDIAN
40#else /* !(__BYTE_ORDER == __LITTLE_ENDIAN) */
41#if __BYTE_ORDER1234 == __BIG_ENDIAN4321
42#define CORE_BIG_ENDIAN
43#undef CORE_LITTLE_ENDIAN
44#endif /* __BYTE_ORDER == __BIG_ENDIAN */
45#endif /* !(__BYTE_ORDER == __LITTLE_ENDIAN) */
46#endif /* Def __linux */

48#if defined(__OpenBSD__) || defined(__FreeBSD__) || \
  defined(__NetBSD__) || defined(__DragonFly__)
50#include <machine/endian.h>
51#if _BYTE_ORDER == _LITTLE_ENDIAN
52#undef CORE_BIG_ENDIAN
53#define CORE_LITTLE_ENDIAN
54#else /* !(_BYTE_ORDER == _LITTLE_ENDIAN) */
55#if _BYTE_ORDER == _BIG_ENDIAN
56#define CORE_BIG_ENDIAN
57#undef CORE_LITTLE_ENDIAN
58#endif /* _BYTE_ORDER == _BIG_ENDIAN */
59#endif /* !(_BYTE_ORDER == _LITTLE_ENDIAN) */
60#endif /* Def *BSD */

62#if defined(__HAIKU__)
63#include <endian.h>
64#if __BYTE_ORDER1234 == __LITTLE_ENDIAN1234
65#undef CORE_BIG_ENDIAN
66#define CORE_LITTLE_ENDIAN
67#else /* !(__BYTE_ORDER == __LITTLE_ENDIAN) */
68#if __BYTE_ORDER1234 == __BIG_ENDIAN4321
69#define CORE_BIG_ENDIAN
70#undef CORE_LITTLE_ENDIAN
71#endif /* __BYTE_ORDER == __BIG_ENDIAN */
72#endif /* !(__BYTE_ORDER == __LITTLE_ENDIAN) */
73#endif /* Def __HAIKU__ */

75#ifdef __sun
76#ifdef __sparc
77#define CORE_BIG_ENDIAN
78#undef CORE_LITTLE_ENDIAN
79#else  /* Ndef __sparc */
80#undef CORE_BIG_ENDIAN
81#define CORE_LITTLE_ENDIAN
82#endif /* Ndef __sparc */
83#endif /* Def __sun */

85#include <assert.h>
86#include <stdio.h>
87#include <stdlib.h>
88#include <sys/types.h>
89#include <sys/stat.h>
90#include <errno(*__errno_location ()).h>
91#include <fcntl.h>
92#include <string.h>
93#include <ctype.h>

95#ifdef _MSC_VER
96#include <io.h>
97#else
98#include <unistd.h>
99#endif

101#include <config_options.h>

103/* modes */
104#ifdef _MSC_VER
105#define FILE_O_RDONLY00     _O_RDONLY
106#define FILE_O_BINARY0     _O_BINARY
107#define PATHNCMPstrncmp _strnicmp /* MSVC converts paths to lower-case sometimes? */
108#define ssize_t long
109#define S_ISREG(mode)((((mode)) & 0170000) == (0100000)) (((mode) & _S_IFMT) == (_S_IFREG)) /* MSVC does not have this macro */
110#else /* not windaube */
111#define FILE_O_RDONLY00     O_RDONLY00
112#define FILE_O_BINARY0     0
113#define PATHNCMPstrncmp strncmp
114#endif /* not windaube */

116#ifndef TRUE1
117#define TRUE1 1
118#endif
119#ifndef FALSE0
120#define FALSE0 0
121#endif

123static int internal_boost = 0;
124static char* base_dir;
125static char* work_dir;
126static size_t work_dir_len;

128#ifdef __GNUC__4
129#define clz__builtin_clz __builtin_clz
130#else
131static int clz__builtin_clz(unsigned int value)
132{
  int result = 32;

  while(value)
  {
      value >>= 1;
      result -= 1;
  }
  return result;
141}
142#endif

144static unsigned int get_unaligned_uint(const unsigned char* cursor)
145{
  unsigned int   result;

  memcpy(&result, cursor, sizeof(unsigned int));
  return result;
150}

152/* ===============================================
* memory pool for fast fix-size allocation (non-thread-safe)
* ===============================================
*/
156struct pool
157{
  void*    head_free;  /**< head of a linked list of freed element */
  char*    fresh;      /**< top of a memory block to dig new element */
  char*    tail;       /**< to detect end of extent... when fresh pass tail */
  void*    extent;     /**< pointer to the primary extent block */
  int      size_elem;  /**< size of an element. */
  int      primary;    /**< primary allocation in bytes */
  int      secondary;  /**< secondary allocation in bytes */
165};
166#define POOL_ALIGN_INCREMENT8 8 /**< alignment, must be a power of 2 and of size > to sizeof(void*) */


169static void* pool_take_extent(struct pool* pool, int allocate)
170{
  unsigned int size = 0;
  void* extent;
  void* data = NULL((void*)0);

  if(pool->extent)
  {
      /* we already have an extent, so this is a secondary */
      if(pool->secondary)
      {
          size = pool->secondary;
      }
  }
  else
  {
      assert(pool->primary)((void) sizeof ((pool->primary) ? 1 : 0), __extension__ ({
 if (pool->primary) ; else __assert_fail ("pool->primary"
, "/home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c"
, 185, __extension__ __PRETTY_FUNCTION__); }));
      size = pool->primary;
  }
  if(size)
  {
      extent = malloc(size);
      if(extent)
      {
          *(void**)extent = pool->extent;
          pool->extent = extent;
          if(allocate)
          {
              data = ((char*)extent) + POOL_ALIGN_INCREMENT8;
              pool->fresh = ((char*)data) + pool->size_elem;
              pool->tail = pool->fresh + (size - pool->size_elem);
          }
          else
          {
              pool->fresh = ((char*)extent) + POOL_ALIGN_INCREMENT8;
              pool->tail = pool->fresh + (size - pool->size_elem);
          }
      }
  }
  return data;
209}

211/* Create a memory pool for fix size objects
* this is a simplified implementation that
* is _not_ thread safe.
*/
215static struct pool* pool_create(int size_elem, int primary, int secondary)
216{
  struct pool* pool;

  assert(primary > 0)((void) sizeof ((primary > 0) ? 1 : 0), __extension__ ({ if
 (primary > 0) ; else __assert_fail ("primary > 0", "/home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c"
, 219, __extension__ __PRETTY_FUNCTION__); }));
  assert(secondary >= 0)((void) sizeof ((secondary >= 0) ? 1 : 0), __extension__ (
{ if (secondary >= 0) ; else __assert_fail ("secondary >= 0"
, "/home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c"
, 220, __extension__ __PRETTY_FUNCTION__); }));
  assert(size_elem > 0)((void) sizeof ((size_elem > 0) ? 1 : 0), __extension__ ({
 if (size_elem > 0) ; else __assert_fail ("size_elem > 0"
, "/home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c"
, 221, __extension__ __PRETTY_FUNCTION__); }));

  pool = (struct pool*)calloc(1, sizeof(struct pool));
  if(!pool) return NULL((void*)0);
  /* Adjust the element size so that it be aligned, and so that an element could
   * at least contain a void*
   */
  pool->size_elem = size_elem = (size_elem + POOL_ALIGN_INCREMENT8 - 1) & ~(POOL_ALIGN_INCREMENT8 - 1);

  pool->primary = (size_elem * primary) + POOL_ALIGN_INCREMENT8;
  pool->secondary = secondary > 0 ? (size_elem * secondary) + POOL_ALIGN_INCREMENT8 : 0;
  pool_take_extent(pool, FALSE0);

  return pool;

236}

238static void pool_destroy(struct pool* pool)
239{
  void* extent;
  void* next;

  if(pool != NULL((void*)0))
  {
      extent = pool->extent;
      while(extent)
      {
          next = *(void**)extent;
          free(extent);
          extent = next;
      }
      free(pool);
  }
254}

256static void* pool_alloc(struct pool* pool)
257{
  void* data;

  data = pool->head_free;
  if(data == NULL((void*)0))
  {
      /* we have no old-freed elem */
      if(pool->fresh <= pool->tail)
      {
          /* pick a slice of the current extent */
          data = (void*)pool->fresh;
          pool->fresh += pool->size_elem;
      }
      else
      {
          /* allocate a new extent */
          data = pool_take_extent(pool, TRUE1);
      }
  }
  else
  {
      /* re-used old freed element by chopping the head of the free list */
      pool->head_free = *(void**)data;
  }

  return data;
283}


286/* ===============================================
* Hash implementation customized to be just tracking
* a unique list of string (i.e no data associated
* with the key, no need for retrieval, etc...
*
* This is tuned for the particular use-case we have here
* measures in tail_build showed that
* we can get north of 4000 distinct values stored in a hash
* the collision rate is at worse around 2%
* the collision needing an expensive memcmp to resolve
* have a rate typically at 1 per 1000
* for tail_build we register 37229 unique key
* with a total of 377 extra memcmp needed
* which is completely negligible compared to the
* number of memcmp required to eliminate duplicate
* entry (north of 2.5 millions for tail_build)
* ===============================================
*/

305struct hash_elem
306{
  struct hash_elem* next;
  const char*    key;
  int      key_len;
310};

312struct hash
313{
  struct hash_elem** array;
  struct pool* elems_pool;
  unsigned int used;
  unsigned int size;
  unsigned int load_limit;
319#ifdef HASH_STAT
  int stored;
  int collisions;
  int cost;
  int memcmp;
324#endif
325};

327/* The following hash_compute function was adapted from :
* lookup3.c, by Bob Jenkins, May 2006, Public Domain.
*
* The changes from the original are mostly cosmetic
*/
332#define rot(x,k)(((x)<<(k)) | ((x)>>(32-(k)))) (((x)<<(k)) | ((x)>>(32-(k))))


335#if defined CORE_BIG_ENDIAN
336#define MASK_C10xFFFFFF 0xFFFFFF00
337#define MASK_C20xFFFF 0xFFFF0000
338#define MASK_C30xFF 0xFF000000
339#elif defined CORE_LITTLE_ENDIAN
340#define MASK_C10xFFFFFF 0xFFFFFF
341#define MASK_C20xFFFF 0xFFFF
342#define MASK_C30xFF 0xFF
343#else
344#error "Missing Endianness definition"
345#endif


348#define mix(a,b,c){ a -= c; a ^= (((c)<<(4)) | ((c)>>(32-(4)))); c +=
 b; b -= a; b ^= (((a)<<(6)) | ((a)>>(32-(6)))); a
 += c; c -= b; c ^= (((b)<<(8)) | ((b)>>(32-(8)))
); b += a; a -= c; a ^= (((c)<<(16)) | ((c)>>(32-
(16)))); c += b; b -= a; b ^= (((a)<<(19)) | ((a)>>
(32-(19)))); a += c; c -= b; c ^= (((b)<<(4)) | ((b)>>
(32-(4)))); b += a; } \
349{ \
a -= c;  a ^= rot(c, 4)(((c)<<(4)) | ((c)>>(32-(4))));  c += b; \
b -= a;  b ^= rot(a, 6)(((a)<<(6)) | ((a)>>(32-(6))));  a += c; \
c -= b;  c ^= rot(b, 8)(((b)<<(8)) | ((b)>>(32-(8))));  b += a; \
a -= c;  a ^= rot(c,16)(((c)<<(16)) | ((c)>>(32-(16))));  c += b; \
b -= a;  b ^= rot(a,19)(((a)<<(19)) | ((a)>>(32-(19))));  a += c; \
c -= b;  c ^= rot(b, 4)(((b)<<(4)) | ((b)>>(32-(4))));  b += a; \
356}
357#define final(a,b,c){ c ^= b; c -= (((b)<<(14)) | ((b)>>(32-(14)))); a
 ^= c; a -= (((c)<<(11)) | ((c)>>(32-(11)))); b ^=
 a; b -= (((a)<<(25)) | ((a)>>(32-(25)))); c ^= b
; c -= (((b)<<(16)) | ((b)>>(32-(16)))); a ^= c; a
 -= (((c)<<(4)) | ((c)>>(32-(4)))); b ^= a; b -= (
((a)<<(14)) | ((a)>>(32-(14)))); c ^= b; c -= (((
b)<<(24)) | ((b)>>(32-(24)))); } \
358{ \
c ^= b; c -= rot(b,14)(((b)<<(14)) | ((b)>>(32-(14)))); \
a ^= c; a -= rot(c,11)(((c)<<(11)) | ((c)>>(32-(11)))); \
b ^= a; b -= rot(a,25)(((a)<<(25)) | ((a)>>(32-(25)))); \
c ^= b; c -= rot(b,16)(((b)<<(16)) | ((b)>>(32-(16)))); \
a ^= c; a -= rot(c,4)(((c)<<(4)) | ((c)>>(32-(4))));  \
b ^= a; b -= rot(a,14)(((a)<<(14)) | ((a)>>(32-(14)))); \
c ^= b; c -= rot(b,24)(((b)<<(24)) | ((b)>>(32-(24)))); \
366}

368static unsigned int hash_compute( struct hash const * hash, const char* key, int length)
369{
  unsigned int a;
  unsigned int b;
  unsigned int c;                                          /* internal state */
  const unsigned char* uk = (const unsigned char*)key;

  /* Set up the internal state */
  a = b = c = 0xdeadbeef + (length << 2);

  /* we use this to 'hash' full path with mostly a common root
   * let's now waste too much cycles hashing mostly constant stuff
   */
  if(length > 36)
  {
      uk += length - 36;
      length = 36;
  }
  /*------ all but last block: aligned reads and affect 32 bits of (a,b,c) */
  while (length > 12)
  {
      a += get_unaligned_uint(uk);
      b += get_unaligned_uint(uk+4);
      c += get_unaligned_uint(uk+8);
      mix(a,b,c){ a -= c; a ^= (((c)<<(4)) | ((c)>>(32-(4)))); c +=
 b; b -= a; b ^= (((a)<<(6)) | ((a)>>(32-(6)))); a
 += c; c -= b; c ^= (((b)<<(8)) | ((b)>>(32-(8)))
); b += a; a -= c; a ^= (((c)<<(16)) | ((c)>>(32-
(16)))); c += b; b -= a; b ^= (((a)<<(19)) | ((a)>>
(32-(19)))); a += c; c -= b; c ^= (((b)<<(4)) | ((b)>>
(32-(4)))); b += a; };
      length -= 12;
      uk += 12;
  }

  /*----------------------------- handle the last (probably partial) block */
  /* Note: we possibly over-read, which would trigger complaint from VALGRIND
   * but we mask the undefined stuff if any, so we are still good, thanks
   * to alignment of memory allocation and tail-memory management overhead
   * we always can read 3 bytes past the official end without triggering
   * a segfault -- if you find a platform/compiler couple for which that postulate
   * is false, then you just need to over-allocate by 2 more bytes in file_load()
   * file_load already over-allocate by 1 to stick a \0 at the end of the buffer.
   */
  switch(length)
  {
  case 12: c+=get_unaligned_uint(uk+8); b+=get_unaligned_uint(uk+4); a+=get_unaligned_uint(uk); break;
  case 11: c+=get_unaligned_uint(uk+8) & MASK_C10xFFFFFF; b+=get_unaligned_uint(uk+4); a+=get_unaligned_uint(uk); break;
  case 10: c+=get_unaligned_uint(uk+8) & MASK_C20xFFFF; b+=get_unaligned_uint(uk+4); a+=get_unaligned_uint(uk); break;
  case 9 : c+=get_unaligned_uint(uk+8) & MASK_C30xFF; b+=get_unaligned_uint(uk+4); a+=get_unaligned_uint(uk); break;
  case 8 : b+=get_unaligned_uint(uk+4); a+=get_unaligned_uint(uk); break;
  case 7 : b+=get_unaligned_uint(uk+4) & MASK_C10xFFFFFF; a+=get_unaligned_uint(uk); break;
  case 6 : b+=get_unaligned_uint(uk+4) & MASK_C20xFFFF; a+=get_unaligned_uint(uk); break;
  case 5 : b+=get_unaligned_uint(uk+4) & MASK_C30xFF; a+=get_unaligned_uint(uk); break;
  case 4 : a+=get_unaligned_uint(uk); break;
  case 3 : a+=get_unaligned_uint(uk) & MASK_C10xFFFFFF; break;
  case 2 : a+=get_unaligned_uint(uk) & MASK_C20xFFFF; break;
  case 1 : a+=get_unaligned_uint(uk) & MASK_C30xFF; break;
  case 0 : return c & hash->size;              /* zero length strings require no mixing */
  }

  final(a,b,c){ c ^= b; c -= (((b)<<(14)) | ((b)>>(32-(14)))); a
 ^= c; a -= (((c)<<(11)) | ((c)>>(32-(11)))); b ^=
 a; b -= (((a)<<(25)) | ((a)>>(32-(25)))); c ^= b
; c -= (((b)<<(16)) | ((b)>>(32-(16)))); a ^= c; a
 -= (((c)<<(4)) | ((c)>>(32-(4)))); b ^= a; b -= (
((a)<<(14)) | ((a)>>(32-(14)))); c ^= b; c -= (((
b)<<(24)) | ((b)>>(32-(24)))); };
  return c & hash->size;
425}

427static void hash_destroy(struct hash* hash)
428{
  if(hash)
  {
      if(hash->array)
      {
          free(hash->array);
      }
      if(hash->elems_pool)
      {
          pool_destroy(hash->elems_pool);
      }
      free(hash);
  }
441}

443static struct hash* hash_create(unsigned int size)
444{
  struct hash* hash;

  assert(size > 0)((void) sizeof ((size > 0) ? 1 : 0), __extension__ ({ if (
size > 0) ; else __assert_fail ("size > 0", "/home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c"
, 447, __extension__ __PRETTY_FUNCTION__); }));
10
←
Taking true branch→
  hash = (struct hash*)(calloc(1, sizeof(struct hash)));
11
←
Memory is allocated→
  if(hash)
12
←
Assuming 'hash' is non-null→
13
←
Taking true branch→
  {
      size += (size >> 2) + 1; /* ~ 75% load factor */
      if(size13.1
'size' is >= 15
 >= 15)
14
←
Taking true branch→
      {
          hash->size = (((unsigned int)0xFFFFFFFF) >> clz__builtin_clz((unsigned int)size));
      }
      else
      {
          hash->size = size = 15;
      }
      hash->load_limit = hash->size - (hash->size >> 2);
      hash->used = 0;
      hash->array = (struct hash_elem**)calloc(hash->size + 1, sizeof(struct hash_elem*));
      if(hash->array == NULL((void*)0))
15
←
Assuming field 'array' is not equal to NULL→
16
←
Taking false branch→
      {
          hash_destroy(hash);
          hash = NULL((void*)0);
      }
  }
  if(hash16.1
'hash' is non-null
)
17
←
Taking true branch→
  {
      hash->elems_pool = pool_create(sizeof(struct hash_elem),
                                     size, size << 1);
      if(!hash->elems_pool17.1
Field 'elems_pool' is non-null
)
18
←
Taking false branch→
      {
          hash_destroy(hash);
          hash = NULL((void*)0);
      }
  }
  return hash;
480}

482static void hash_resize(struct hash* hash)
483{
  unsigned int old_size = hash->size;
  unsigned int hashed;
  struct hash_elem* hash_elem;
  struct hash_elem* next;
  struct hash_elem** array;
  unsigned int i;

  hash->size = (old_size << 1) + 1;
  /* we really should avoid to get there... so print a message to alert of the condition */
  fprintf(stderrstderr, "resize hash %u -> %u\n", old_size, hash->size);
  if(hash->size == old_size)
  {
      return;
  }
  array = (struct hash_elem**)calloc(hash->size + 1, sizeof(struct hash_elem*));
  if(array)
  {
      hash->load_limit = hash->size - (hash->size >> 2);
      for(i=0; i <= old_size; i++)
      {
          hash_elem = (struct hash_elem*)hash->array[i];
          while(hash_elem)
          {
              next = hash_elem->next;

              hashed = hash_compute(hash, hash_elem->key, hash_elem->key_len);
              hash_elem->next = array[hashed];
              array[hashed] = hash_elem;
              hash_elem = next;
          }
      }
      free(hash->array);
      hash->array = (struct hash_elem**)array;
  }
  else
  {
      hash->size = old_size;
  }
522}

524static int compare_key(struct hash const * hash, const char* a, const char* b, int len, int const * cost)
525{
526#ifdef HASH_STAT
  *cost += 1;
  hash->memcmp += 1;
529#else
  (void) hash;
  (void) cost;
532#endif
  return memcmp(a,b, len);
534}

536/* a customized hash_store function that just store the key and return
* TRUE if the key was effectively stored, or FALSE if the key was already there
*/
539static int hash_store(struct hash* hash, const char* key, int key_len)
540{
  unsigned int hashed;
  struct hash_elem* hash_elem;
  int cost = 0;

  (void) cost;
  hashed = hash_compute(hash, key, key_len);
547#ifdef HASH_STAT
  hash->stored += 1;
549#endif
  hash_elem = (struct hash_elem*)hash->array[hashed];
  while(hash_elem && (hash_elem->key_len != key_len || compare_key(hash, hash_elem->key, key, key_len, &cost)))
  {
      hash_elem = hash_elem->next;
  }

  if(!hash_elem)
  {
      hash_elem = (struct hash_elem*)pool_alloc(hash->elems_pool);
      if(hash_elem)
      {
          hash_elem->key = key;
          hash_elem->key_len = key_len;
          hash_elem->next = hash->array[hashed];

565#ifdef HASH_STAT
          if(hash_elem->next)
          {
              hash->collisions += 1;
              hash->cost += cost;
          }
571#endif
          hash->array[hashed] = hash_elem;
          hash->used += 1;
          if(hash->used > hash->load_limit)
          {
              hash_resize(hash);
          }
      }
      return TRUE1;
  }
  return FALSE0;
582}

584static int file_stat(const char* name, struct stat* buffer_stat, int* rc)
585{
  int rc_local = stat(name, buffer_stat);
  if (rc_local  < 0)
  {
      *rc = errno(*__errno_location ());
  }
  return rc_local;
592}

594static off_t file_get_size(const char* name, int* rc)
595{
  struct stat buffer_stat;
  off_t       size = -1;

  if (!file_stat(name, &buffer_stat, rc))
  {
      if(S_ISREG(buffer_stat.st_mode)((((buffer_stat.st_mode)) & 0170000) == (0100000)))
      {
          size = buffer_stat.st_size;
      }
      else
      {
          *rc = EINVAL22;
      }
  }
  return size;
611}

613#if !ENABLE_RUNTIME_OPTIMIZATIONS1
614static void * file_load_buffers[100000];
615static size_t file_load_buffer_count = 0;
616#endif

618static char* file_load(const char* name, off_t* size, int* return_rc)
619{
  off_t local_size = 0;
  int rc = 0;
  char* buffer = NULL((void*)0);
  int fd;

  assert(name != NULL)((void) sizeof ((name != ((void*)0)) ? 1 : 0), __extension__ (
{ if (name != ((void*)0)) ; else __assert_fail ("name != NULL"
, "/home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c"
, 625, __extension__ __PRETTY_FUNCTION__); }));

  if(!size)
  {
      size = &local_size;
  }
  *size = file_get_size(name, &rc);
  if (!rc && *size >= 0)
  {
      fd = open(name, FILE_O_RDONLY00 | FILE_O_BINARY0);
      if (!(fd == -1))
      {
          buffer = (char*)malloc((size_t)(*size + 1));
638#if !ENABLE_RUNTIME_OPTIMIZATIONS1
          if (buffer != NULL((void*)0))
          {
              if (file_load_buffer_count == 100000)
              {
                  free(buffer);
                  buffer = NULL((void*)0);
              }
              else
              {
                  file_load_buffers[file_load_buffer_count++] = buffer;
              }
          }
651#endif
          if (buffer == NULL((void*)0))
          {
              rc = ENOMEM12;
          }
          else
          {
              ssize_t i;

            REDO:
              i = read(fd, buffer, (size_t)(*size));
              if(i == -1)
              {
                  if(errno(*__errno_location ()) == EINTR4)
                  {
                      goto REDO;
                  }
                  else
                  {
                      rc = errno(*__errno_location ());
                  }
              }
              else
              {
                  if (i != *size)
                  {
                      rc = EIO5;
                  }
              }
              buffer[*size] = 0;
          }
          close(fd);
      }
  }

  if(rc && buffer)
  {
      free(buffer);
      buffer = NULL((void*)0);
  }
  if(return_rc)
  {
      *return_rc = rc;
  }
  return buffer;
696}

698static void cancel_relative(char const * base, char** ref_cursor, char** ref_cursor_out, char const * end)
699{
  char* cursor = *ref_cursor;
  char* cursor_out = *ref_cursor_out;

  do
  {
      cursor += 3;
      while(cursor_out > base && cursor_out[-1] == '/')
          cursor_out--;
      while(cursor_out > base && *--cursor_out != '/');
  }
  while(cursor + 3 < end && !memcmp(cursor, "/../", 4));
  *ref_cursor = cursor;
  *ref_cursor_out = cursor_out;
713}

715static void eat_space(char ** token)
716{
  while ((' ' == **token) || ('\t' == **token)) {
      ++(*token);
  }
720}

722/*
* Prune LibreOffice specific duplicate dependencies to improve
* gnumake startup time, and shrink the disk-space footprint.
*/
726static int
727elide_dependency(const char* key, int key_len, const char **unpacked_end)
728{
729#if 0
  {
      int i;
      fprintf (stderrstderr, "elide?%d!: '", internal_boost);
      for (i = 0; i < key_len; i++) {
          fprintf (stderrstderr, "%c", key[i]);
      }
      fprintf (stderrstderr, "'\n");
  }
738#endif

  /* boost brings a plague of header files */
  int i;
  int unpacked = 0;
  /* walk down path elements */
  for (i = 0; i < key_len - 1; i++)
  {
      if (key[i] == '/')
      {
          if (0 == unpacked)
          {
              if (!PATHNCMPstrncmp(key + i + 1, "workdir/", 8))
              {
                  unpacked = 1;
                  continue;
              }
          }
          else
          {
              if (!PATHNCMPstrncmp(key + i + 1, "UnpackedTarball/", 16))
              {
                  if (unpacked_end)
                      *unpacked_end = strchr(key + i + 17, '/');
                  return 1;
              }
          }
      }
  }

  return 0;
769}

771/*
* We collapse tens of internal boost headers to the unpacked target, such
* that you can re-compile / install boost and all is well.
*/
775static void emit_single_boost_header(void)
776{
777#define BOOST_TARGET"/UnpackedTarball/boost.done" "/UnpackedTarball/boost.done"
  fprintf(stdoutstdout, "%s" BOOST_TARGET"/UnpackedTarball/boost.done" " ", work_dir);
779}

781static void emit_unpacked_target(const char* token, const char* end)
782{
  fwrite(token, 1, end-token, stdoutstdout);
  fputs(".done ", stdoutstdout);
785}

787/* prefix paths to absolute */
788static void print_fullpaths(char* line)
789{
  char* token;
  char* end;
  int boost_count = 0;
  int token_len;
  const char * unpacked_end = NULL((void*)0); /* end of UnpackedTarget match (if any) */
  /* for UnpackedTarget the target is GenC{,xx}Object, don't mangle! */
  int target_seen = 0;

  token = line;
  eat_space(&token);
  while (*token)
  {
      end = token;
      /* hard to believe that in this day and age drive letters still exist */
      if (*end && (':' == *(end+1)) &&
          (('\\' == *(end+2)) || ('/' == *(end+2))) &&
          isalpha((unsigned char)*end)((*__ctype_b_loc ())[(int) (((unsigned char)*end))] & (unsigned
 short int) _ISalpha))
      {
          end = end + 3; /* only one cross, err drive letter per filename */
      }
      while (*end && (' ' != *end) && ('\t' != *end) && (':' != *end)) {
          ++end;
      }
      token_len = end - token;
      if (target_seen &&
          elide_dependency(token, token_len, &unpacked_end))
      {
          if (unpacked_end)
          {
              if (internal_boost && !PATHNCMPstrncmp(unpacked_end - 5, "boost", 5))
              {
                  ++boost_count;
                  if (boost_count == 1)
                      emit_single_boost_header();
                  else
                  {
                      /* don't output, and swallow trailing \\\n if any */
                      token = end;
                      eat_space(&token);
                      if (token[0] == '\\' && token[1] == '\n')
                          end = token + 2;
                  }
              }
              else
              {
                  emit_unpacked_target(token, unpacked_end);
              }
              unpacked_end = NULL((void*)0);
          }
      }
      else
      {
          if (fwrite(token, token_len, 1, stdoutstdout) != 1)
              abort();
          fputc(' ', stdoutstdout);
      }
      token = end;
      eat_space(&token);
      if (!target_seen && ':' == *token)
      {
          target_seen = 1;
          fputc(':', stdoutstdout);
          ++token;
          eat_space(&token);
      }
  }
856}

858static char * eat_space_at_end(char * end)
859{
  char * real_end;
  assert('\0' == *end)((void) sizeof (('\0' == *end) ? 1 : 0), __extension__ ({ if (
'\0' == *end) ; else __assert_fail ("'\\0' == *end", "/home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c"
, 861, __extension__ __PRETTY_FUNCTION__); }));
  real_end = end - 1;
  while (' ' == *real_end || '\t' == *real_end || '\n' == *real_end
              || ':' == *real_end)
  {    /* eat colon and whitespace at end */
       --real_end;
  }
  return real_end;
869}

871static char* phony_content_buffer;
872static char* generate_phony_line(char const * phony_target, char const * extension)
873{
  char const * src;
  char* dest;
  char* last_dot = NULL((void*)0);
  //fprintf(stderr, "generate_phony_line called with phony_target %s and extension %s\n", phony_target, extension);
  for(dest = phony_content_buffer+work_dir_len+1, src = phony_target; *src != 0; ++src, ++dest)
  {
      *dest = *src;
      if(*dest == '.')
      {
          last_dot = dest;
      }
  }
  //fprintf(stderr, "generate_phony_line after phony_target copy: %s\n", phony_content_buffer);
  for(dest = last_dot+1, src = extension; *src != 0; ++src, ++dest)
  {
      *dest = *src;
  }
  //fprintf(stderr, "generate_phony_line after extension add: %s\n", phony_content_buffer);
  strcpy(dest, ": $(gb_Helper_PHONY)\n");
  //fprintf(stderr, "generate_phony_line after phony add: %s\n", phony_content_buffer);
  return phony_content_buffer;
895}

897static int generate_phony_file(char* fn, char const * content)
898{
  FILE* depfile;
  depfile = fopen(fn, "w");
  if(!depfile)
  {
      fprintf(stderrstderr, "Could not open '%s' for writing: %s\n", fn, strerror(errno(*__errno_location ())));
  }
  else
  {
      fputs(content, depfile);
      fclose(depfile);
  }
  return !depfile;
911}

913static int process(struct hash* dep_hash, char* fn)
914{
  int rc;
  char* buffer;
  char* end;
  char* cursor;
  char* cursor_out;
  char* base;
  char* created_line = NULL((void*)0);
  char* src_relative;
  int continuation = 0;
  char last_ns = 0;
  off_t size;

  buffer = file_load(fn, &size, &rc);
  if(!rc)
  {
      base = cursor_out = cursor = end = buffer;
      end += size;

      /* first eat unneeded space at the beginning of file
       */
      while(cursor < end && (*cursor == ' ' || *cursor == '\\'))
          ++cursor;

      while(cursor < end)
      {
          if(*cursor == '\\')
          {
              continuation = 1;
              *cursor_out++ = *cursor++;
          }
          else if(*cursor == '/')
          {
              if(cursor + 3 < end)
              {
                  if(!memcmp(cursor, "/../", 4))
                  {
                      cancel_relative(base, &cursor, &cursor_out, end);
                  }
              }
              *cursor_out++ = *cursor++;
          }
          else if(*cursor == '\n')
          {
              if(!continuation)
              {
                  *cursor_out = 0;
                  if(base < cursor)
                  {
                      /* here we have a complete rule */
                      if(last_ns == ':')
                      {
                          /* if the rule ended in ':' that is a no-dep rule
                           * these are the one for which we want to filter
                           * duplicate out
                           */
                          int key_len = eat_space_at_end(cursor_out) - base;
                          if (!elide_dependency(base,key_len + 1, NULL((void*)0))
                              && hash_store(dep_hash, base, key_len))
                          {
                              /* DO NOT modify base after it has been added
                                 as key by hash_store */
                              print_fullpaths(base);
                              putc('\n', stdoutstdout);
                          }
                      }
                      else
                      {
                          /* rule with dep, just write it */
                          print_fullpaths(base);
                          putc('\n', stdoutstdout);
                      }
                      last_ns = ' '; // cannot hurt to reset it
                  }
                  cursor += 1;
                  base = cursor_out = cursor;
              }
              else
              {
                  /* here we have a '\' followed by \n this is a continuation
                   * i.e not a complete rule yet
                   */
                  *cursor_out++ = *cursor++;
                  continuation = 0; // cancel current one (empty lines!)
              }
          }
          else
          {
              continuation = 0;
              /* not using isspace() here save 25% of I refs and 75% of D refs based on cachegrind */
              if(*cursor != ' ' && *cursor != '\n' && *cursor != '\t' )
              {
                  last_ns = *cursor;
              }
              *cursor_out++ = *cursor++;
          }
      }
      /* just in case the file did not end with a \n, there may be a pending rule */
      if(base < cursor_out)
      {
          if(last_ns == ':')
          {
              int key_len = eat_space_at_end(cursor_out) - base;
              if (!elide_dependency(base,key_len + 1, NULL((void*)0)) &&
                  hash_store(dep_hash, base, key_len))
              {
                  puts(base);
                  putc('\n', stdoutstdout);
              }
          }
          else
          {
              puts(base);
              putc('\n', stdoutstdout);
          }
      }
  }
  else
  {
      if(strncmp(fn, work_dir, work_dir_len) == 0)
      {
          if(strncmp(fn+work_dir_len, "/Dep/", 5) == 0)
          {
              src_relative = fn+work_dir_len+5;
              // cases ordered by frequency
              if(strncmp(src_relative, "CxxObject/", 10) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else if(strncmp(src_relative, "GenCxxObject/", 13) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else if(strncmp(src_relative, "CObject/", 8) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else if(strncmp(src_relative, "GenCObject/", 11) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else if(strncmp(src_relative, "SdiObject/", 10) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else if(strncmp(src_relative, "AsmObject/", 10) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else if(strncmp(src_relative, "ObjCxxObject/", 13) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else if(strncmp(src_relative, "ObjCObject/", 11) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else if(strncmp(src_relative, "CxxClrObject/", 13) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else if(strncmp(src_relative, "GenCxxClrObject/", 16) == 0)
              {
                  created_line = generate_phony_line(src_relative, "o");
                  rc = generate_phony_file(fn, created_line);
              }
              else
              {
                  fprintf(stderrstderr, "no magic for %s(%s) in %s\n", fn, src_relative, work_dir);
              }
          }
          if(!rc)
          {
              puts(created_line);
          }
      }
  }
  /* Note: yes we are going to leak 'buffer'
   * this is on purpose, to avoid cloning the 'key' out of it and our special
   * 'hash' just store the pointer to the key inside of buffer, hence it need
   * to remain allocated
   */
  // coverity[leaked_storage] - this is on purpose
  return rc;
1107}

1109static void usage(void)
1110{
  fputs("Usage: concat-deps <file that contains dep_files>\n", stderrstderr);
1112}

1114#define kDEFAULT_HASH_SIZE4096 4096
1115#define PHONY_TARGET_BUFFER4096 4096

1117static int get_var(char **var, const char *name)
1118{
  *var = (char *)getenv(name);
  if(!*var)
  {
      fprintf(stderrstderr,"Error: %s is missing in the environment\n", name);
      return 1;
  }
  return 0;
1126}

1128int main(int argc, char** argv)
1129{
  int rc = 0;
  off_t in_list_size = 0;
  char* in_list;
  char* in_list_cursor;
  char* in_list_base;
  struct hash* dep_hash = NULL((void*)0);
  const char *env_str;

  if(argc < 2)
1
Assuming 'argc' is >= 2→
2
←
Taking false branch→
  {
      usage();
      return 1;
  }
  if(get_var(&base_dir, "SRCDIR") || get_var(&work_dir, "WORKDIR"))
3
←
Taking false branch→
      return 1;
  work_dir_len = strlen(work_dir);
  phony_content_buffer = (char*)malloc(PHONY_TARGET_BUFFER4096);
  assert(phony_content_buffer)((void) sizeof ((phony_content_buffer) ? 1 : 0), __extension__
 ({ if (phony_content_buffer) ; else __assert_fail ("phony_content_buffer"
, "/home/maarten/src/libreoffice/core/solenv/bin/concat-deps.c"
, 1147, __extension__ __PRETTY_FUNCTION__); })); // Don't handle OOM conditions
4
←
Assuming 'phony_content_buffer' is non-null→
5
←
Taking true branch→
  strcpy(phony_content_buffer, work_dir);
  phony_content_buffer[work_dir_len] = '/';

  env_str = getenv("SYSTEM_BOOST");
  internal_boost = !env_str || strcmp(env_str,"TRUE");
6
←
Assuming 'env_str' is null→

  in_list = file_load(argv[1], &in_list_size, &rc);
  if(!rc)
7
←
Assuming 'rc' is 0→
8
←
Taking true branch→
  {
      dep_hash = hash_create( kDEFAULT_HASH_SIZE4096);
9
←
Calling 'hash_create'→
19
←
Returned allocated memory→
      in_list_base = in_list_cursor = in_list;

      /* extract filename of dep file from a 'space' separated list */
      while(*in_list_cursor)
20
←
Loop condition is false. Execution continues on line 1184→
      {
          /* the input here may contain Win32 \r\n EOL */
          if(*in_list_cursor == ' '
              || *in_list_cursor == '\n' || *in_list_cursor == '\r')
          {
              *in_list_cursor = 0;
              if(in_list_base < in_list_cursor)
              {
                  rc = process(dep_hash, in_list_base);
                  if(rc)
                  {
                      break;
                  }
              }
              in_list_cursor += 1;
              in_list_base = in_list_cursor;
          }
          else
          {
              in_list_cursor += 1;
          }
      }
      if(!rc20.1
'rc' is 0
)
21
←
Taking true branch→
      {
          /* catch the last entry in case the input did not terminate with a 'space' */
          if(in_list_base21.1
'in_list_base' is >= 'in_list_cursor'
 < in_list_cursor)
22
←
Taking false branch→
          {
              rc = process(dep_hash, in_list_base);
          }
      }
1192#ifdef HASH_STAT
      fprintf(stderrstderr, "stats: u:%d s:%d l:%d t:%d c:%d m:%d $:%d\n",
              dep_hash->used, dep_hash->size, dep_hash->load_limit, dep_hash->stored,
              dep_hash->collisions, dep_hash->memcmp, dep_hash->cost);
1196#endif
  }
1198#if !ENABLE_RUNTIME_OPTIMIZATIONS1
  {
      size_t i;
      hash_destroy(dep_hash);
      for (i = 0; i != file_load_buffer_count; ++i)
      {
          free(file_load_buffers[i]);
      }
  }
1207#endif
  return rc;
23
←
Potential leak of memory pointed to by 'dep_hash'
1209}

1211/* vim:set shiftwidth=4 softtabstop=4 expandtab: */