#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

5.16M

Z_INTERNAL uint32_t UPDATE_HASH(uint32_t h, uint32_t val) {

50

5.16M

    HASH_CALC(h, val);

51

5.16M

    return h & HASH_CALC_MASK;

52

5.16M

}

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

 * 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) {

    Pos head;

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

    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;

    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

3.01M

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

60

3.01M

    Pos head;

61

3.01M

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

62

3.01M

    uint32_t val, hm;

63

64

3.01M

    HASH_CALC_VAR_INIT;

65

3.01M

    HASH_CALC_READ;

66

3.01M

    HASH_CALC(HASH_CALC_VAR, val);

67

3.01M

    HASH_CALC_VAR &= HASH_CALC_MASK;

68

3.01M

    hm = HASH_CALC_VAR;

69

70

3.01M

    head = s->head[hm];

71

3.01M

    if (LIKELY(head != str)) {

72

3.00M

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

73

3.00M

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

74

3.00M

    }

75

3.01M

    return head;

76

3.01M

}

quick_insert_string_roll

Line

Count

Source

59

2.28M

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

60

2.28M

    Pos head;

61

2.28M

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

62

2.28M

    uint32_t val, hm;

63

64

2.28M

    HASH_CALC_VAR_INIT;

65

2.28M

    HASH_CALC_READ;

66

2.28M

    HASH_CALC(HASH_CALC_VAR, val);

67

2.28M

    HASH_CALC_VAR &= HASH_CALC_MASK;

68

2.28M

    hm = HASH_CALC_VAR;

69

70

2.28M

    head = s->head[hm];

71

2.28M

    if (LIKELY(head != str)) {

72

2.28M

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

73

2.28M

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

74

2.28M

    }

75

2.28M

    return head;

76

2.28M

}

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

 * 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;

    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 = s->head[hm];

        if (LIKELY(head != idx)) {

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

            s->head[hm] = idx;

        }

    }

}

insert_string

Line

Count

Source

86

236k

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

87

236k

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

88

236k

    uint8_t *strend = strstart + count;

89

90

6.46M

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

91

6.22M

        uint32_t val, hm;

92

93

6.22M

        HASH_CALC_VAR_INIT;

94

6.22M

        HASH_CALC_READ;

95

6.22M

        HASH_CALC(HASH_CALC_VAR, val);

96

6.22M

        HASH_CALC_VAR &= HASH_CALC_MASK;

97

6.22M

        hm = HASH_CALC_VAR;

98

99

6.22M

        Pos head = s->head[hm];

100

6.22M

        if (LIKELY(head != idx)) {

101

6.22M

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

102

6.22M

            s->head[hm] = idx;

103

6.22M

        }

104

6.22M

    }

105

236k

}

insert_string_roll

Line

Count

Source

86

264k

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

87

264k

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

88

264k

    uint8_t *strend = strstart + count;

89

90

4.80M

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

91

4.54M

        uint32_t val, hm;

92

93

4.54M

        HASH_CALC_VAR_INIT;

94

4.54M

        HASH_CALC_READ;

95

4.54M

        HASH_CALC(HASH_CALC_VAR, val);

96

4.54M

        HASH_CALC_VAR &= HASH_CALC_MASK;

97

4.54M

        hm = HASH_CALC_VAR;

98

99

4.54M

        Pos head = s->head[hm];

100

4.54M

        if (LIKELY(head != idx)) {

101

4.53M

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

102

4.53M

            s->head[hm] = idx;

103

4.53M

        }

104

4.54M

    }

105

264k

}

#endif