← Back to branch summary

~ubuntu-branches/ubuntu/precise/postgresql-9.1/precise-security

« back to all changes in this revision

Viewing changes to src/include/utils/pg_crc.h

  • Committer: Bazaar Package Importer
  • Author(s): Martin Pitt
  • Date: 2011-05-11 10:41:53 UTC
  • Revision ID: james.westby@ubuntu.com-20110511104153-psbh2o58553fv1m0
Tags: upstream-9.1~beta1
Import upstream version 9.1~beta1

Show diffs side-by-side

added added

removed removed

Lines of Context:
src/include/utils/pg_crc.h
 
1
/*
 
2
 * pg_crc.h
 
3
 *
 
4
 * PostgreSQL CRC support
 
5
 *
 
6
 * See Ross Williams' excellent introduction
 
7
 * A PAINLESS GUIDE TO CRC ERROR DETECTION ALGORITHMS, available from
 
8
 * http://www.ross.net/crc/ or several other net sites.
 
9
 *
 
10
 * We use a normal (not "reflected", in Williams' terms) CRC, using initial
 
11
 * all-ones register contents and a final bit inversion.
 
12
 *
 
13
 * The 64-bit variant is not used as of PostgreSQL 8.1, but we retain the
 
14
 * code for possible future use.
 
15
 *
 
16
 *
 
17
 * Portions Copyright (c) 1996-2011, PostgreSQL Global Development Group
 
18
 * Portions Copyright (c) 1994, Regents of the University of California
 
19
 *
 
20
 * src/include/utils/pg_crc.h
 
21
 */
 
22
#ifndef PG_CRC_H
 
23
#define PG_CRC_H
 
24
 
 
25
/* ugly hack to let this be used in frontend and backend code on Cygwin */
 
26
#ifdef FRONTEND
 
27
#define CRCDLLIMPORT
 
28
#else
 
29
#define CRCDLLIMPORT PGDLLIMPORT
 
30
#endif
 
31
 
 
32
typedef uint32 pg_crc32;
 
33
 
 
34
/* Initialize a CRC accumulator */
 
35
#define INIT_CRC32(crc) ((crc) = 0xFFFFFFFF)
 
36
 
 
37
/* Finish a CRC calculation */
 
38
#define FIN_CRC32(crc)  ((crc) ^= 0xFFFFFFFF)
 
39
 
 
40
/* Accumulate some (more) bytes into a CRC */
 
41
#define COMP_CRC32(crc, data, len)      \
 
42
do { \
 
43
        unsigned char *__data = (unsigned char *) (data); \
 
44
        uint32          __len = (len); \
 
45
\
 
46
        while (__len-- > 0) \
 
47
        { \
 
48
                int             __tab_index = ((int) ((crc) >> 24) ^ *__data++) & 0xFF; \
 
49
                (crc) = pg_crc32_table[__tab_index] ^ ((crc) << 8); \
 
50
        } \
 
51
} while (0)
 
52
 
 
53
/* Check for equality of two CRCs */
 
54
#define EQ_CRC32(c1,c2)  ((c1) == (c2))
 
55
 
 
56
/* Constant table for CRC calculation */
 
57
extern CRCDLLIMPORT const uint32 pg_crc32_table[];
 
58
 
 
59
 
 
60
#ifdef PROVIDE_64BIT_CRC
 
61
 
 
62
/*
 
63
 * If we use a 64-bit integer type, then a 64-bit CRC looks just like the
 
64
 * usual sort of implementation.  However, we can also fake it with two
 
65
 * 32-bit registers.  Experience has shown that the two-32-bit-registers code
 
66
 * is as fast as, or even much faster than, the 64-bit code on all but true
 
67
 * 64-bit machines.  We use SIZEOF_VOID_P to check the native word width.
 
68
 */
 
69
 
 
70
#if SIZEOF_VOID_P < 8
 
71
 
 
72
/*
 
73
 * crc0 represents the LSBs of the 64-bit value, crc1 the MSBs.  Note that
 
74
 * with crc0 placed first, the output of 32-bit and 64-bit implementations
 
75
 * will be bit-compatible only on little-endian architectures.  If it were
 
76
 * important to make the two possible implementations bit-compatible on
 
77
 * all machines, we could do a configure test to decide how to order the
 
78
 * two fields, but it seems not worth the trouble.
 
79
 */
 
80
typedef struct pg_crc64
 
81
{
 
82
        uint32          crc0;
 
83
        uint32          crc1;
 
84
}       pg_crc64;
 
85
 
 
86
/* Initialize a CRC accumulator */
 
87
#define INIT_CRC64(crc) ((crc).crc0 = 0xffffffff, (crc).crc1 = 0xffffffff)
 
88
 
 
89
/* Finish a CRC calculation */
 
90
#define FIN_CRC64(crc)  ((crc).crc0 ^= 0xffffffff, (crc).crc1 ^= 0xffffffff)
 
91
 
 
92
/* Accumulate some (more) bytes into a CRC */
 
93
#define COMP_CRC64(crc, data, len)      \
 
94
do { \
 
95
        uint32          __crc0 = (crc).crc0; \
 
96
        uint32          __crc1 = (crc).crc1; \
 
97
        unsigned char *__data = (unsigned char *) (data); \
 
98
        uint32          __len = (len); \
 
99
\
 
100
        while (__len-- > 0) \
 
101
        { \
 
102
                int             __tab_index = ((int) (__crc1 >> 24) ^ *__data++) & 0xFF; \
 
103
                __crc1 = pg_crc64_table1[__tab_index] ^ ((__crc1 << 8) | (__crc0 >> 24)); \
 
104
                __crc0 = pg_crc64_table0[__tab_index] ^ (__crc0 << 8); \
 
105
        } \
 
106
        (crc).crc0 = __crc0; \
 
107
        (crc).crc1 = __crc1; \
 
108
} while (0)
 
109
 
 
110
/* Check for equality of two CRCs */
 
111
#define EQ_CRC64(c1,c2)  ((c1).crc0 == (c2).crc0 && (c1).crc1 == (c2).crc1)
 
112
 
 
113
/* Constant table for CRC calculation */
 
114
extern CRCDLLIMPORT const uint32 pg_crc64_table0[];
 
115
extern CRCDLLIMPORT const uint32 pg_crc64_table1[];
 
116
#else                                                   /* use int64 implementation */
 
117
 
 
118
typedef struct pg_crc64
 
119
{
 
120
        uint64          crc0;
 
121
}       pg_crc64;
 
122
 
 
123
/* Initialize a CRC accumulator */
 
124
#define INIT_CRC64(crc) ((crc).crc0 = UINT64CONST(0xffffffffffffffff))
 
125
 
 
126
/* Finish a CRC calculation */
 
127
#define FIN_CRC64(crc)  ((crc).crc0 ^= UINT64CONST(0xffffffffffffffff))
 
128
 
 
129
/* Accumulate some (more) bytes into a CRC */
 
130
#define COMP_CRC64(crc, data, len)      \
 
131
do { \
 
132
        uint64          __crc0 = (crc).crc0; \
 
133
        unsigned char *__data = (unsigned char *) (data); \
 
134
        uint32          __len = (len); \
 
135
\
 
136
        while (__len-- > 0) \
 
137
        { \
 
138
                int             __tab_index = ((int) (__crc0 >> 56) ^ *__data++) & 0xFF; \
 
139
                __crc0 = pg_crc64_table[__tab_index] ^ (__crc0 << 8); \
 
140
        } \
 
141
        (crc).crc0 = __crc0; \
 
142
} while (0)
 
143
 
 
144
/* Check for equality of two CRCs */
 
145
#define EQ_CRC64(c1,c2)  ((c1).crc0 == (c2).crc0)
 
146
 
 
147
/* Constant table for CRC calculation */
 
148
extern CRCDLLIMPORT const uint64 pg_crc64_table[];
 
149
#endif   /* SIZEOF_VOID_P < 8 */
 
150
#endif   /* PROVIDE_64BIT_CRC */
 
151
 
 
152
#endif   /* PG_CRC_H */