25
26 #include "precompiled.hpp"
27 #include "asm/macroAssembler.inline.hpp"
28 #include "runtime/stubRoutines.hpp"
29
30 // Implementation of the platform-specific part of StubRoutines - for
31 // a description of how to extend it, see the stubRoutines.hpp file.
32
33
34 #define __ masm->
35
36 // CRC32(C) Intrinsics.
37 void StubRoutines::ppc64::generate_load_crc_table_addr(MacroAssembler* masm, Register table) {
38 __ load_const_optimized(table, StubRoutines::_crc_table_adr, R0);
39 }
40
41 void StubRoutines::ppc64::generate_load_crc_constants_addr(MacroAssembler* masm, Register table) {
42 __ load_const_optimized(table, (address)StubRoutines::ppc64::_crc_constants, R0);
43 }
44
45 void StubRoutines::ppc64::generate_load_crc_barret_constants_addr(MacroAssembler* masm, Register table) {
46 __ load_const_optimized(table, (address)StubRoutines::ppc64::_crc_barret_constants, R0);
47 }
48
49 void StubRoutines::ppc64::generate_load_crc32c_table_addr(MacroAssembler* masm, Register table) {
50 __ load_const_optimized(table, StubRoutines::_crc32c_table_addr, R0);
51 }
52
53 void StubRoutines::ppc64::generate_load_crc32c_constants_addr(MacroAssembler* masm, Register table) {
54 __ load_const_optimized(table, (address)StubRoutines::ppc64::_crc32c_constants, R0);
55 }
56
57 void StubRoutines::ppc64::generate_load_crc32c_barret_constants_addr(MacroAssembler* masm, Register table) {
58 __ load_const_optimized(table, (address)StubRoutines::ppc64::_crc32c_barret_constants, R0);
59 }
60
61 // CRC constants and compute functions
62 #define REVERSE_CRC32_POLY 0xEDB88320
63 #define REVERSE_CRC32C_POLY 0x82F63B78
64 #define INVERSE_REVERSE_CRC32_POLY 0x1aab14226ull
65 #define INVERSE_REVERSE_CRC32C_POLY 0x105fd79bdull
66 #define UNROLL_FACTOR 2048
67 #define UNROLL_FACTOR2 8
68
69 static juint fold_word(juint w, juint reverse_poly) {
70 for (int i = 0; i < 32; i++) {
71 int poly_if_odd = (-(w & 1)) & reverse_poly;
72 w = (w >> 1) ^ poly_if_odd;
73 }
74 return w;
75 }
76
77 static julong numberOfLeadingZeros(julong p) {
78 julong l = 1ull << 63;
79 for (int i = 0; i < 64; ++i) {
80 if (p & l) return i;
81 l >>= 1;
82 }
83 return 64;
84 }
85
86 static julong compute_inverse_poly(julong long_poly) {
87 // 2^64 / p
88 julong mod = 0, div = 0;
89 int d = numberOfLeadingZeros(long_poly);
90 int s = d + 1;
91 do {
92 mod ^= (long_poly << s);
93 div |= (1L << s);
94 s = d - numberOfLeadingZeros(mod);
95 } while (s >= 0);
96 return div;
97 }
98
99 // Constants to fold n words as needed by macroAssembler.
100 juint* StubRoutines::ppc64::generate_crc_constants(juint reverse_poly) {
101 juint* ptr = (juint*) malloc(sizeof(juint) * 4 * (UNROLL_FACTOR2 - 1 + UNROLL_FACTOR / UNROLL_FACTOR2));
102 guarantee(((intptr_t)ptr & 0xF) == 0, "16-byte alignment needed");
103 guarantee(ptr != NULL, "allocation error of a crc table");
104
105 // Generate constants for outer loop
106 juint v0, v1, v2, v3 = 1;
107 for (int i = 0; i < UNROLL_FACTOR2 - 1; ++i) {
108 v0 = fold_word(v3, reverse_poly);
109 v1 = fold_word(v0, reverse_poly);
110 v2 = fold_word(v1, reverse_poly);
111 v3 = fold_word(v2, reverse_poly);
112 #ifdef VM_LITTLE_ENDIAN
113 ptr[4*i ] = v3;
114 ptr[4*i+1] = v2;
115 ptr[4*i+2] = v3;
116 ptr[4*i+3] = v2;
117 #else
118 ptr[4*i ] = v2;
119 ptr[4*i+1] = v3;
120 ptr[4*i+2] = v2;
121 ptr[4*i+3] = v3;
122 #endif
123 }
124
125 // Generate constants for inner loop
126 juint* ptr2 = ptr + 4 * (UNROLL_FACTOR2 - 1);
127 v3 = 1; // Restart from scratch.
128 for (int i = 0; i < UNROLL_FACTOR; ++i) {
129 v0 = fold_word(v3, reverse_poly);
130 v1 = fold_word(v0, reverse_poly);
131 v2 = fold_word(v1, reverse_poly);
132 v3 = fold_word(v2, reverse_poly);
133 if (i % UNROLL_FACTOR2 == 0) {
134 int idx = UNROLL_FACTOR / UNROLL_FACTOR2 - 1 - i / UNROLL_FACTOR2;
135 for (int j = 0; j < 4; ++j) {
136 #ifdef VM_LITTLE_ENDIAN
137 ptr2[4*idx ] = v3;
138 ptr2[4*idx+1] = v2;
139 ptr2[4*idx+2] = v1;
140 ptr2[4*idx+3] = v0;
141 #else
142 ptr2[4*idx ] = v0;
143 ptr2[4*idx+1] = v1;
144 ptr2[4*idx+2] = v2;
145 ptr2[4*idx+3] = v3;
146 #endif
147 }
148 }
149 }
150
151 return ptr;
152 }
153
154 // Constants to reduce 64 to 32 bit as needed by macroAssembler.
155 juint* StubRoutines::ppc64::generate_crc_barret_constants(juint reverse_poly) {
156 juint* ptr = (juint*) malloc(sizeof(juint) * CRC32_BARRET_CONSTANTS);
157 guarantee(((intptr_t)ptr & 0xF) == 0, "16-byte alignment needed");
158 guarantee(ptr != NULL, "allocation error of a crc table");
159
160 julong* c = (julong*)ptr;
161 julong long_poly = (((julong)reverse_poly) << 1) | 1;
162 julong inverse_long_poly = compute_inverse_poly(long_poly);
163 #ifdef VM_LITTLE_ENDIAN
164 c[0] = inverse_long_poly;
165 c[1] = long_poly;
166 #else
167 c[0] = long_poly;
168 c[1] = inverse_long_poly;
169 #endif
170
171 #ifdef ASSERT
172 if (reverse_poly == REVERSE_CRC32_POLY) {
173 assert(INVERSE_REVERSE_CRC32_POLY == inverse_long_poly, "sanity");
174 } else if (reverse_poly == REVERSE_CRC32C_POLY) {
175 assert(INVERSE_REVERSE_CRC32C_POLY == inverse_long_poly, "sanity");
176 }
177 #endif
178
179 //printf("inv poly: 0x%016llx\n", (long long unsigned int)inverse_long_poly);
180 return ptr;
181 }
182
183 // CRC32 Intrinsics.
184 /**
185 * crc_table[] from jdk/src/share/native/java/util/zip/zlib-1.2.8/crc32.h
186 */
187 juint StubRoutines::ppc64::_crc_table[CRC32_TABLES][CRC32_COLUMN_SIZE] = {
188 /* polyBits = 7976584769 0x00000001db710641L, shifted = 0xedb88320 */
189 /* CRC32 table for single bytes, auto-generated. DO NOT MODIFY! */
190 /* CRC32 table 0 for quad-bytes (little-endian), auto-generated. DO NOT MODIFY! */
191 {
192 /* 0 */ 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U, 0x706af48fU, 0xe963a535U, 0x9e6495a3U
193 /* 8 */ , 0x0edb8832U, 0x79dcb8a4U, 0xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, 0x90bf1d91U
194 /* 16 */ , 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU, 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U
195 /* 24 */ , 0x136c9856U, 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U, 0xfa0f3d63U, 0x8d080df5U
196 /* 32 */ , 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U, 0xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU
197 /* 40 */ , 0x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U
198 /* 48 */ , 0x26d930acU, 0x51de003aU, 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U, 0xb8bda50fU
199 /* 56 */ , 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U, 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU
757 /* 144 */ , 0x0278c4bbU, 0xbad28166U, 0x835ba304U, 0x3bf1e6d9U, 0xf149e6c0U, 0x49e3a31dU, 0x706a817fU, 0xc8c0c4a2U
758 /* 152 */ , 0xe41b804dU, 0x5cb1c590U, 0x6538e7f2U, 0xdd92a22fU, 0x172aa236U, 0xaf80e7ebU, 0x9609c589U, 0x2ea38054U
759 /* 160 */ , 0xb4dd8585U, 0x0c77c058U, 0x35fee23aU, 0x8d54a7e7U, 0x47eca7feU, 0xff46e223U, 0xc6cfc041U, 0x7e65859cU
760 /* 168 */ , 0x52bec173U, 0xea1484aeU, 0xd39da6ccU, 0x6b37e311U, 0xa18fe308U, 0x1925a6d5U, 0x20ac84b7U, 0x9806c16aU
761 /* 176 */ , 0x896ce16cU, 0x31c6a4b1U, 0x084f86d3U, 0xb0e5c30eU, 0x7a5dc317U, 0xc2f786caU, 0xfb7ea4a8U, 0x43d4e175U
762 /* 184 */ , 0x6f0fa59aU, 0xd7a5e047U, 0xee2cc225U, 0x568687f8U, 0x9c3e87e1U, 0x2494c23cU, 0x1d1de05eU, 0xa5b7a583U
763 /* 192 */ , 0xd89606f9U, 0x603c4324U, 0x59b56146U, 0xe11f249bU, 0x2ba72482U, 0x930d615fU, 0xaa84433dU, 0x122e06e0U
764 /* 200 */ , 0x3ef5420fU, 0x865f07d2U, 0xbfd625b0U, 0x077c606dU, 0xcdc46074U, 0x756e25a9U, 0x4ce707cbU, 0xf44d4216U
765 /* 208 */ , 0xe5276210U, 0x5d8d27cdU, 0x640405afU, 0xdcae4072U, 0x1616406bU, 0xaebc05b6U, 0x973527d4U, 0x2f9f6209U
766 /* 216 */ , 0x034426e6U, 0xbbee633bU, 0x82674159U, 0x3acd0484U, 0xf075049dU, 0x48df4140U, 0x71566322U, 0xc9fc26ffU
767 /* 224 */ , 0x5382232eU, 0xeb2866f3U, 0xd2a14491U, 0x6a0b014cU, 0xa0b30155U, 0x18194488U, 0x219066eaU, 0x993a2337U
768 /* 232 */ , 0xb5e167d8U, 0x0d4b2205U, 0x34c20067U, 0x8c6845baU, 0x46d045a3U, 0xfe7a007eU, 0xc7f3221cU, 0x7f5967c1U
769 /* 240 */ , 0x6e3347c7U, 0xd699021aU, 0xef102078U, 0x57ba65a5U, 0x9d0265bcU, 0x25a82061U, 0x1c210203U, 0xa48b47deU
770 /* 248 */ , 0x88500331U, 0x30fa46ecU, 0x0973648eU, 0xb1d92153U, 0x7b61214aU, 0xc3cb6497U, 0xfa4246f5U, 0x42e80328U
771 }
772 #endif
773 };
774
775 juint* StubRoutines::ppc64::_crc_constants = StubRoutines::ppc64::generate_crc_constants(REVERSE_CRC32_POLY);
776 juint* StubRoutines::ppc64::_crc32c_constants = StubRoutines::ppc64::generate_crc_constants(REVERSE_CRC32C_POLY);
777
778 juint* StubRoutines::ppc64::_crc_barret_constants = StubRoutines::ppc64::generate_crc_barret_constants(REVERSE_CRC32_POLY);
779 juint* StubRoutines::ppc64::_crc32c_barret_constants = StubRoutines::ppc64::generate_crc_barret_constants(REVERSE_CRC32C_POLY);
|
25
26 #include "precompiled.hpp"
27 #include "asm/macroAssembler.inline.hpp"
28 #include "runtime/stubRoutines.hpp"
29
30 // Implementation of the platform-specific part of StubRoutines - for
31 // a description of how to extend it, see the stubRoutines.hpp file.
32
33
34 #define __ masm->
35
36 // CRC32(C) Intrinsics.
37 void StubRoutines::ppc64::generate_load_crc_table_addr(MacroAssembler* masm, Register table) {
38 __ load_const_optimized(table, StubRoutines::_crc_table_adr, R0);
39 }
40
41 void StubRoutines::ppc64::generate_load_crc_constants_addr(MacroAssembler* masm, Register table) {
42 __ load_const_optimized(table, (address)StubRoutines::ppc64::_crc_constants, R0);
43 }
44
45 void StubRoutines::ppc64::generate_load_crc32c_table_addr(MacroAssembler* masm, Register table) {
46 __ load_const_optimized(table, StubRoutines::_crc32c_table_addr, R0);
47 }
48
49 void StubRoutines::ppc64::generate_load_crc32c_constants_addr(MacroAssembler* masm, Register table) {
50 __ load_const_optimized(table, (address)StubRoutines::ppc64::_crc32c_constants, R0);
51 }
52
53 // CRC constant compute functions
54 static juint fold_word(juint w, juint reverse_poly) {
55 for (int i = 0; i < 32; i++) {
56 int poly_if_odd = (-(w & 1)) & reverse_poly;
57 w = (w >> 1) ^ poly_if_odd;
58 }
59 return w;
60 }
61
62 static julong numberOfLeadingZeros(julong p) {
63 julong l = 1ull << 63;
64 for (int i = 0; i < 64; ++i) {
65 if (p & l) return i;
66 l >>= 1;
67 }
68 return 64;
69 }
70
71 static julong compute_inverse_poly(julong long_poly) {
72 // 2^64 / p
73 julong mod = 0, div = 0;
74 int d = numberOfLeadingZeros(long_poly);
75 int s = d + 1;
76 do {
77 mod ^= (long_poly << s);
78 div |= (1L << s);
79 s = d - numberOfLeadingZeros(mod);
80 } while (s >= 0);
81 return div;
82 }
83
84 // Constants to fold n words as needed by macroAssembler.
85 juint* StubRoutines::ppc64::generate_crc_constants(juint reverse_poly) {
86 juint* ptr = (juint*) malloc(sizeof(juint) * 4 * (CRC32_UNROLL_FACTOR2 + CRC32_UNROLL_FACTOR / CRC32_UNROLL_FACTOR2));
87 guarantee(((intptr_t)ptr & 0xF) == 0, "16-byte alignment needed");
88 guarantee(ptr != NULL, "allocation error of a crc table");
89
90 // Generate constants for outer loop
91 juint v0, v1, v2, v3 = 1;
92 for (int i = 0; i < CRC32_UNROLL_FACTOR2 - 1; ++i) {
93 v0 = fold_word(v3, reverse_poly);
94 v1 = fold_word(v0, reverse_poly);
95 v2 = fold_word(v1, reverse_poly);
96 v3 = fold_word(v2, reverse_poly);
97 #ifdef VM_LITTLE_ENDIAN
98 ptr[4*i ] = v3;
99 ptr[4*i+1] = v2;
100 ptr[4*i+2] = v3;
101 ptr[4*i+3] = v2;
102 #else
103 ptr[4*i ] = v2;
104 ptr[4*i+1] = v3;
105 ptr[4*i+2] = v2;
106 ptr[4*i+3] = v3;
107 #endif
108 }
109
110 // Generate constants for inner loop
111 juint* ptr2 = ptr + 4 * (CRC32_UNROLL_FACTOR2 - 1);
112 v3 = 1; // Restart from scratch.
113 for (int i = 0; i < CRC32_UNROLL_FACTOR; ++i) {
114 v0 = fold_word(v3, reverse_poly);
115 v1 = fold_word(v0, reverse_poly);
116 v2 = fold_word(v1, reverse_poly);
117 v3 = fold_word(v2, reverse_poly);
118 if (i % CRC32_UNROLL_FACTOR2 == 0) {
119 int idx = CRC32_UNROLL_FACTOR / CRC32_UNROLL_FACTOR2 - 1 - i / CRC32_UNROLL_FACTOR2;
120 for (int j = 0; j < 4; ++j) {
121 #ifdef VM_LITTLE_ENDIAN
122 ptr2[4*idx ] = v3;
123 ptr2[4*idx+1] = v2;
124 ptr2[4*idx+2] = v1;
125 ptr2[4*idx+3] = v0;
126 #else
127 ptr2[4*idx ] = v0;
128 ptr2[4*idx+1] = v1;
129 ptr2[4*idx+2] = v2;
130 ptr2[4*idx+3] = v3;
131 #endif
132 }
133 }
134 }
135
136 // Constants to reduce 64 to 32 bit as needed by macroAssembler.
137 juint* ptr3 = ptr2 + 4 * (CRC32_UNROLL_FACTOR / CRC32_UNROLL_FACTOR2);
138 julong* c = (julong*)ptr3;
139 julong long_poly = (((julong)reverse_poly) << 1) | 1;
140 julong inverse_long_poly = compute_inverse_poly(long_poly);
141 #ifdef VM_LITTLE_ENDIAN
142 c[0] = inverse_long_poly;
143 c[1] = long_poly;
144 #else
145 c[0] = long_poly;
146 c[1] = inverse_long_poly;
147 #endif
148
149 #ifdef ASSERT
150 if (reverse_poly == REVERSE_CRC32_POLY) {
151 assert(INVERSE_REVERSE_CRC32_POLY == inverse_long_poly, "sanity");
152 } else if (reverse_poly == REVERSE_CRC32C_POLY) {
153 assert(INVERSE_REVERSE_CRC32C_POLY == inverse_long_poly, "sanity");
154 }
155 #endif
156
157 //printf("inv poly: 0x%016llx\n", (long long unsigned int)inverse_long_poly);
158
159 return ptr;
160 }
161
162 // CRC32 Intrinsics.
163 /**
164 * crc_table[] from jdk/src/share/native/java/util/zip/zlib-1.2.8/crc32.h
165 */
166 juint StubRoutines::ppc64::_crc_table[CRC32_TABLES][CRC32_COLUMN_SIZE] = {
167 /* polyBits = 7976584769 0x00000001db710641L, shifted = 0xedb88320 */
168 /* CRC32 table for single bytes, auto-generated. DO NOT MODIFY! */
169 /* CRC32 table 0 for quad-bytes (little-endian), auto-generated. DO NOT MODIFY! */
170 {
171 /* 0 */ 0x00000000U, 0x77073096U, 0xee0e612cU, 0x990951baU, 0x076dc419U, 0x706af48fU, 0xe963a535U, 0x9e6495a3U
172 /* 8 */ , 0x0edb8832U, 0x79dcb8a4U, 0xe0d5e91eU, 0x97d2d988U, 0x09b64c2bU, 0x7eb17cbdU, 0xe7b82d07U, 0x90bf1d91U
173 /* 16 */ , 0x1db71064U, 0x6ab020f2U, 0xf3b97148U, 0x84be41deU, 0x1adad47dU, 0x6ddde4ebU, 0xf4d4b551U, 0x83d385c7U
174 /* 24 */ , 0x136c9856U, 0x646ba8c0U, 0xfd62f97aU, 0x8a65c9ecU, 0x14015c4fU, 0x63066cd9U, 0xfa0f3d63U, 0x8d080df5U
175 /* 32 */ , 0x3b6e20c8U, 0x4c69105eU, 0xd56041e4U, 0xa2677172U, 0x3c03e4d1U, 0x4b04d447U, 0xd20d85fdU, 0xa50ab56bU
176 /* 40 */ , 0x35b5a8faU, 0x42b2986cU, 0xdbbbc9d6U, 0xacbcf940U, 0x32d86ce3U, 0x45df5c75U, 0xdcd60dcfU, 0xabd13d59U
177 /* 48 */ , 0x26d930acU, 0x51de003aU, 0xc8d75180U, 0xbfd06116U, 0x21b4f4b5U, 0x56b3c423U, 0xcfba9599U, 0xb8bda50fU
178 /* 56 */ , 0x2802b89eU, 0x5f058808U, 0xc60cd9b2U, 0xb10be924U, 0x2f6f7c87U, 0x58684c11U, 0xc1611dabU, 0xb6662d3dU
736 /* 144 */ , 0x0278c4bbU, 0xbad28166U, 0x835ba304U, 0x3bf1e6d9U, 0xf149e6c0U, 0x49e3a31dU, 0x706a817fU, 0xc8c0c4a2U
737 /* 152 */ , 0xe41b804dU, 0x5cb1c590U, 0x6538e7f2U, 0xdd92a22fU, 0x172aa236U, 0xaf80e7ebU, 0x9609c589U, 0x2ea38054U
738 /* 160 */ , 0xb4dd8585U, 0x0c77c058U, 0x35fee23aU, 0x8d54a7e7U, 0x47eca7feU, 0xff46e223U, 0xc6cfc041U, 0x7e65859cU
739 /* 168 */ , 0x52bec173U, 0xea1484aeU, 0xd39da6ccU, 0x6b37e311U, 0xa18fe308U, 0x1925a6d5U, 0x20ac84b7U, 0x9806c16aU
740 /* 176 */ , 0x896ce16cU, 0x31c6a4b1U, 0x084f86d3U, 0xb0e5c30eU, 0x7a5dc317U, 0xc2f786caU, 0xfb7ea4a8U, 0x43d4e175U
741 /* 184 */ , 0x6f0fa59aU, 0xd7a5e047U, 0xee2cc225U, 0x568687f8U, 0x9c3e87e1U, 0x2494c23cU, 0x1d1de05eU, 0xa5b7a583U
742 /* 192 */ , 0xd89606f9U, 0x603c4324U, 0x59b56146U, 0xe11f249bU, 0x2ba72482U, 0x930d615fU, 0xaa84433dU, 0x122e06e0U
743 /* 200 */ , 0x3ef5420fU, 0x865f07d2U, 0xbfd625b0U, 0x077c606dU, 0xcdc46074U, 0x756e25a9U, 0x4ce707cbU, 0xf44d4216U
744 /* 208 */ , 0xe5276210U, 0x5d8d27cdU, 0x640405afU, 0xdcae4072U, 0x1616406bU, 0xaebc05b6U, 0x973527d4U, 0x2f9f6209U
745 /* 216 */ , 0x034426e6U, 0xbbee633bU, 0x82674159U, 0x3acd0484U, 0xf075049dU, 0x48df4140U, 0x71566322U, 0xc9fc26ffU
746 /* 224 */ , 0x5382232eU, 0xeb2866f3U, 0xd2a14491U, 0x6a0b014cU, 0xa0b30155U, 0x18194488U, 0x219066eaU, 0x993a2337U
747 /* 232 */ , 0xb5e167d8U, 0x0d4b2205U, 0x34c20067U, 0x8c6845baU, 0x46d045a3U, 0xfe7a007eU, 0xc7f3221cU, 0x7f5967c1U
748 /* 240 */ , 0x6e3347c7U, 0xd699021aU, 0xef102078U, 0x57ba65a5U, 0x9d0265bcU, 0x25a82061U, 0x1c210203U, 0xa48b47deU
749 /* 248 */ , 0x88500331U, 0x30fa46ecU, 0x0973648eU, 0xb1d92153U, 0x7b61214aU, 0xc3cb6497U, 0xfa4246f5U, 0x42e80328U
750 }
751 #endif
752 };
753
754 juint* StubRoutines::ppc64::_crc_constants = StubRoutines::ppc64::generate_crc_constants(REVERSE_CRC32_POLY);
755 juint* StubRoutines::ppc64::_crc32c_constants = StubRoutines::ppc64::generate_crc_constants(REVERSE_CRC32C_POLY);
|