#ifndef INSERT_STRING_H_

#define INSERT_STRING_H_

/* insert_string_tpl.h -- Private insert_string functions shared with more than

 *                        one insert string implementation

 *

 * Copyright (C) 1995-2024 Jean-loup Gailly and Mark Adler

 *

 * Copyright (C) 2013 Intel Corporation. All rights reserved.

 * Authors:

 *  Wajdi Feghali   <wajdi.k.feghali@intel.com>

 *  Jim Guilford    <james.guilford@intel.com>

 *  Vinodh Gopal    <vinodh.gopal@intel.com>

 *  Erdinc Ozturk   <erdinc.ozturk@intel.com>

 *  Jim Kukunas     <james.t.kukunas@linux.intel.com>

 *

 * Portions are Copyright (C) 2016 12Sided Technology, LLC.

 * Author:

 *  Phil Vachon     <pvachon@12sidedtech.com>

 *

 * For conditions of distribution and use, see copyright notice in zlib.h

 *

 */

#include "zmemory.h"

#ifndef HASH_CALC_OFFSET

#  define HASH_CALC_OFFSET 0

#endif

#ifndef HASH_CALC_MASK

#  define HASH_CALC_MASK HASH_MASK

#endif

#ifndef HASH_CALC_READ

#  if BYTE_ORDER == LITTLE_ENDIAN

#    define HASH_CALC_READ \

        val = zng_memread_4(strstart);

#  else

#    define HASH_CALC_READ \

        val = ZSWAP32(zng_memread_4(strstart));

#  endif

#endif

/* ===========================================================================

 * Update a hash value with the given input byte

 * IN  assertion: all calls to UPDATE_HASH are made with consecutive

 *    input characters, so that a running hash key can be computed from the

 *    previous key instead of complete recalculation each time.

 */

Z_INTERNAL uint32_t UPDATE_HASH(uint32_t h, uint32_t val) {

    HASH_CALC(h, val);

    return h & HASH_CALC_MASK;

}

Unexecuted instantiation: update_hash

update_hash_roll

Line

Count

Source

49

4.72M

Z_INTERNAL uint32_t UPDATE_HASH(uint32_t h, uint32_t val) {

50

4.72M

    HASH_CALC(h, val);

51

4.72M

    return h & HASH_CALC_MASK;

52

4.72M

}

/* ===========================================================================

 * Quick insert string str in the dictionary and set match_head to the previous head

 * of the hash chain (the most recent string with same hash key). Return

 * the previous length of the hash chain.

 */

Z_INTERNAL Pos QUICK_INSERT_STRING(deflate_state *const s, uint32_t str) {

    uint8_t *strstart = s->window + str + HASH_CALC_OFFSET;

    uint32_t val, hm;

    Pos head;

    HASH_CALC_VAR_INIT;

    HASH_CALC_READ;

    HASH_CALC(HASH_CALC_VAR, val);

    HASH_CALC_VAR &= HASH_CALC_MASK;

    hm = HASH_CALC_VAR;

    head = s->head[hm];

    if (LIKELY(head != str)) {

        s->prev[str & s->w_mask] = head;

        s->head[hm] = (Pos)str;

    }

    return head;

}

quick_insert_string

Line

Count

Source

59

2.87M

Z_INTERNAL Pos QUICK_INSERT_STRING(deflate_state *const s, uint32_t str) {

60

2.87M

    uint8_t *strstart = s->window + str + HASH_CALC_OFFSET;

61

2.87M

    uint32_t val, hm;

62

2.87M

    Pos head;

63

64

2.87M

    HASH_CALC_VAR_INIT;

65

2.87M

    HASH_CALC_READ;

66

2.87M

    HASH_CALC(HASH_CALC_VAR, val);

67

2.87M

    HASH_CALC_VAR &= HASH_CALC_MASK;

68

2.87M

    hm = HASH_CALC_VAR;

69

70

2.87M

    head = s->head[hm];

71

2.87M

    if (LIKELY(head != str)) {

72

2.86M

        s->prev[str & s->w_mask] = head;

73

2.86M

        s->head[hm] = (Pos)str;

74

2.86M

    }

75

2.87M

    return head;

76

2.87M

}

quick_insert_string_roll

Line

Count

Source

59

2.25M

Z_INTERNAL Pos QUICK_INSERT_STRING(deflate_state *const s, uint32_t str) {

60

2.25M

    uint8_t *strstart = s->window + str + HASH_CALC_OFFSET;

61

2.25M

    uint32_t val, hm;

62

2.25M

    Pos head;

63

64

2.25M

    HASH_CALC_VAR_INIT;

65

2.25M

    HASH_CALC_READ;

66

2.25M

    HASH_CALC(HASH_CALC_VAR, val);

67

2.25M

    HASH_CALC_VAR &= HASH_CALC_MASK;

68

2.25M

    hm = HASH_CALC_VAR;

69

70

2.25M

    head = s->head[hm];

71

2.25M

    if (LIKELY(head != str)) {

72

2.25M

        s->prev[str & s->w_mask] = head;

73

2.25M

        s->head[hm] = (Pos)str;

74

2.25M

    }

75

2.25M

    return head;

76

2.25M

}

/* ===========================================================================

 * Insert string str in the dictionary and set match_head to the previous head

 * of the hash chain (the most recent string with same hash key). Return

 * the previous length of the hash chain.

 * IN  assertion: all calls to INSERT_STRING are made with consecutive

 *    input characters and the first STD_MIN_MATCH bytes of str are valid

 *    (except for the last STD_MIN_MATCH-1 bytes of the input file).

 */

Z_INTERNAL void INSERT_STRING(deflate_state *const s, uint32_t str, uint32_t count) {

    uint8_t *strstart = s->window + str + HASH_CALC_OFFSET;

    uint8_t *strend = strstart + count;

    /* Local pointers to avoid indirection */

    Pos *headp = s->head;

    Pos *prevp = s->prev;

    const unsigned int w_mask = s->w_mask;

    for (Pos idx = (Pos)str; strstart < strend; idx++, strstart++) {

        uint32_t val, hm;

        HASH_CALC_VAR_INIT;

        HASH_CALC_READ;

        HASH_CALC(HASH_CALC_VAR, val);

        HASH_CALC_VAR &= HASH_CALC_MASK;

        hm = HASH_CALC_VAR;

        Pos head = headp[hm];

        if (LIKELY(head != idx)) {

            prevp[idx & w_mask] = head;

            headp[hm] = idx;

        }

    }

}

insert_string

Line

Count

Source

86

212k

Z_INTERNAL void INSERT_STRING(deflate_state *const s, uint32_t str, uint32_t count) {

87

212k

    uint8_t *strstart = s->window + str + HASH_CALC_OFFSET;

88

212k

    uint8_t *strend = strstart + count;

89

90

    /* Local pointers to avoid indirection */

91

212k

    Pos *headp = s->head;

92

212k

    Pos *prevp = s->prev;

93

212k

    const unsigned int w_mask = s->w_mask;

94

95

4.49M

    for (Pos idx = (Pos)str; strstart < strend; idx++, strstart++) {

96

4.27M

        uint32_t val, hm;

97

98

4.27M

        HASH_CALC_VAR_INIT;

99

4.27M

        HASH_CALC_READ;

100

4.27M

        HASH_CALC(HASH_CALC_VAR, val);

101

4.27M

        HASH_CALC_VAR &= HASH_CALC_MASK;

102

4.27M

        hm = HASH_CALC_VAR;

103

104

4.27M

        Pos head = headp[hm];

105

4.27M

        if (LIKELY(head != idx)) {

106

4.27M

            prevp[idx & w_mask] = head;

107

4.27M

            headp[hm] = idx;

108

4.27M

        }

109

4.27M

    }

110

212k

}

insert_string_roll

Line

Count

Source

86

259k

Z_INTERNAL void INSERT_STRING(deflate_state *const s, uint32_t str, uint32_t count) {

87

259k

    uint8_t *strstart = s->window + str + HASH_CALC_OFFSET;

88

259k

    uint8_t *strend = strstart + count;

89

90

    /* Local pointers to avoid indirection */

91

259k

    Pos *headp = s->head;

92

259k

    Pos *prevp = s->prev;

93

259k

    const unsigned int w_mask = s->w_mask;

94

95

4.62M

    for (Pos idx = (Pos)str; strstart < strend; idx++, strstart++) {

96

4.36M

        uint32_t val, hm;

97

98

4.36M

        HASH_CALC_VAR_INIT;

99

4.36M

        HASH_CALC_READ;

100

4.36M

        HASH_CALC(HASH_CALC_VAR, val);

101

4.36M

        HASH_CALC_VAR &= HASH_CALC_MASK;

102

4.36M

        hm = HASH_CALC_VAR;

103

104

4.36M

        Pos head = headp[hm];

105

4.36M

        if (LIKELY(head != idx)) {

106

4.36M

            prevp[idx & w_mask] = head;

107

4.36M

            headp[hm] = idx;

108

4.36M

        }

109

4.36M

    }

110

259k

}

#endif