3 // Copyright 2018 The Go Authors. All rights reserved.
4 // Use of this source code is governed by a BSD-style
5 // license that can be found in the LICENSE file.
11 // ----------------------- //
12 // bits.LeadingZeros //
13 // ----------------------- //
15 func LeadingZeros(n uint) int {
18 // arm:"CLZ" arm64:"CLZ"
20 return bits.LeadingZeros(n)
23 func LeadingZeros64(n uint64) int {
26 // arm:"CLZ" arm64:"CLZ"
28 return bits.LeadingZeros64(n)
31 func LeadingZeros32(n uint32) int {
32 // amd64:"BSRQ","LEAQ",-"CMOVQEQ"
34 // arm:"CLZ" arm64:"CLZ"
36 return bits.LeadingZeros32(n)
39 func LeadingZeros16(n uint16) int {
40 // amd64:"BSRL","LEAL",-"CMOVQEQ"
42 // arm:"CLZ" arm64:"CLZ"
44 return bits.LeadingZeros16(n)
47 func LeadingZeros8(n uint8) int {
48 // amd64:"BSRL","LEAL",-"CMOVQEQ"
50 // arm:"CLZ" arm64:"CLZ"
52 return bits.LeadingZeros8(n)
59 func Len(n uint) int {
62 // arm:"CLZ" arm64:"CLZ"
67 func Len64(n uint64) int {
70 // arm:"CLZ" arm64:"CLZ"
75 func Len32(n uint32) int {
76 // amd64:"BSRQ","LEAQ",-"CMOVQEQ"
78 // arm:"CLZ" arm64:"CLZ"
83 func Len16(n uint16) int {
84 // amd64:"BSRL","LEAL",-"CMOVQEQ"
86 // arm:"CLZ" arm64:"CLZ"
91 func Len8(n uint8) int {
92 // amd64:"BSRL","LEAL",-"CMOVQEQ"
94 // arm:"CLZ" arm64:"CLZ"
99 // -------------------- //
101 // -------------------- //
103 func OnesCount(n uint) int {
104 // amd64:"POPCNTQ",".*x86HasPOPCNT"
105 // arm64:"VCNT","VUADDLV"
109 return bits.OnesCount(n)
112 func OnesCount64(n uint64) int {
113 // amd64:"POPCNTQ",".*x86HasPOPCNT"
114 // arm64:"VCNT","VUADDLV"
118 return bits.OnesCount64(n)
121 func OnesCount32(n uint32) int {
122 // amd64:"POPCNTL",".*x86HasPOPCNT"
123 // arm64:"VCNT","VUADDLV"
127 return bits.OnesCount32(n)
130 func OnesCount16(n uint16) int {
131 // amd64:"POPCNTL",".*x86HasPOPCNT"
132 // arm64:"VCNT","VUADDLV"
136 return bits.OnesCount16(n)
139 func OnesCount8(n uint8) int {
143 return bits.OnesCount8(n)
146 // ----------------------- //
147 // bits.ReverseBytes //
148 // ----------------------- //
150 func ReverseBytes(n uint) uint {
154 return bits.ReverseBytes(n)
157 func ReverseBytes64(n uint64) uint64 {
161 return bits.ReverseBytes64(n)
164 func ReverseBytes32(n uint32) uint32 {
168 return bits.ReverseBytes32(n)
171 func ReverseBytes16(n uint16) uint16 {
173 return bits.ReverseBytes16(n)
176 // --------------------- //
177 // bits.RotateLeft //
178 // --------------------- //
180 func RotateLeft64(n uint64) uint64 {
186 return bits.RotateLeft64(n, 37)
189 func RotateLeft32(n uint32) uint32 {
190 // amd64:"ROLL" 386:"ROLL"
195 return bits.RotateLeft32(n, 9)
198 func RotateLeft16(n uint16) uint16 {
199 // amd64:"ROLW" 386:"ROLW"
200 return bits.RotateLeft16(n, 5)
203 func RotateLeft8(n uint8) uint8 {
204 // amd64:"ROLB" 386:"ROLB"
205 return bits.RotateLeft8(n, 5)
208 func RotateLeftVariable(n uint, m int) uint {
214 return bits.RotateLeft(n, m)
217 func RotateLeftVariable64(n uint64, m int) uint64 {
223 return bits.RotateLeft64(n, m)
226 func RotateLeftVariable32(n uint32, m int) uint32 {
232 return bits.RotateLeft32(n, m)
235 // ------------------------ //
236 // bits.TrailingZeros //
237 // ------------------------ //
239 func TrailingZeros(n uint) int {
240 // amd64:"BSFQ","MOVL\t\\$64","CMOVQEQ"
242 // ppc64:"ANDN","POPCNTD"
243 // ppc64le:"ANDN","POPCNTD"
244 return bits.TrailingZeros(n)
247 func TrailingZeros64(n uint64) int {
248 // amd64:"BSFQ","MOVL\t\\$64","CMOVQEQ"
250 // ppc64:"ANDN","POPCNTD"
251 // ppc64le:"ANDN","POPCNTD"
252 return bits.TrailingZeros64(n)
255 func TrailingZeros32(n uint32) int {
256 // amd64:"BTSQ\\t\\$32","BSFQ"
257 // s390x:"FLOGR","MOVWZ"
258 // ppc64:"ANDN","POPCNTW"
259 // ppc64le:"ANDN","POPCNTW"
260 return bits.TrailingZeros32(n)
263 func TrailingZeros16(n uint16) int {
264 // amd64:"BSFL","BTSL\\t\\$16"
265 // s390x:"FLOGR","OR\t\\$65536"
266 // ppc64:"POPCNTD","OR\\t\\$65536"
267 // ppc64le:"POPCNTD","OR\\t\\$65536"
268 return bits.TrailingZeros16(n)
271 func TrailingZeros8(n uint8) int {
272 // amd64:"BSFL","BTSL\\t\\$8"
273 // s390x:"FLOGR","OR\t\\$256"
274 return bits.TrailingZeros8(n)
277 // IterateBitsNN checks special handling of TrailingZerosNN when the input is known to be non-zero.
279 func IterateBits(n uint) int {
282 // amd64:"BSFQ",-"CMOVEQ"
283 i += bits.TrailingZeros(n)
289 func IterateBits64(n uint64) int {
292 // amd64:"BSFQ",-"CMOVEQ"
293 i += bits.TrailingZeros64(n)
299 func IterateBits32(n uint32) int {
302 // amd64:"BSFL",-"BTSQ"
303 i += bits.TrailingZeros32(n)
309 func IterateBits16(n uint16) int {
312 // amd64:"BSFL",-"BTSL"
313 i += bits.TrailingZeros16(n)
319 func IterateBits8(n uint8) int {
322 // amd64:"BSFL",-"BTSL"
323 i += bits.TrailingZeros8(n)
329 // --------------- //
331 // --------------- //
333 func Add(x, y, ci uint) (r, co uint) {
334 // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
335 return bits.Add(x, y, ci)
338 func AddC(x, ci uint) (r, co uint) {
339 // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
340 return bits.Add(x, 7, ci)
343 func AddZ(x, y uint) (r, co uint) {
344 // amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
345 return bits.Add(x, y, 0)
348 func AddR(x, y, ci uint) uint {
349 // amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
350 r, _ := bits.Add(x, y, ci)
353 func AddM(p, q, r *[3]uint) {
355 r[0], c = bits.Add(p[0], q[0], c)
356 // amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
357 r[1], c = bits.Add(p[1], q[1], c)
358 r[2], c = bits.Add(p[2], q[2], c)
361 func Add64(x, y, ci uint64) (r, co uint64) {
362 // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
363 return bits.Add64(x, y, ci)
366 func Add64C(x, ci uint64) (r, co uint64) {
367 // amd64:"NEGL","ADCQ","SBBQ","NEGQ"
368 return bits.Add64(x, 7, ci)
371 func Add64Z(x, y uint64) (r, co uint64) {
372 // amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
373 return bits.Add64(x, y, 0)
376 func Add64R(x, y, ci uint64) uint64 {
377 // amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
378 r, _ := bits.Add64(x, y, ci)
381 func Add64M(p, q, r *[3]uint64) {
383 r[0], c = bits.Add64(p[0], q[0], c)
384 // amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
385 r[1], c = bits.Add64(p[1], q[1], c)
386 r[2], c = bits.Add64(p[2], q[2], c)
389 // --------------- //
391 // --------------- //
393 func Sub(x, y, ci uint) (r, co uint) {
394 // amd64:"NEGL","SBBQ","NEGQ"
395 return bits.Sub(x, y, ci)
398 func SubC(x, ci uint) (r, co uint) {
399 // amd64:"NEGL","SBBQ","NEGQ"
400 return bits.Sub(x, 7, ci)
403 func SubZ(x, y uint) (r, co uint) {
404 // amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
405 return bits.Sub(x, y, 0)
408 func SubR(x, y, ci uint) uint {
409 // amd64:"NEGL","SBBQ",-"NEGQ"
410 r, _ := bits.Sub(x, y, ci)
413 func SubM(p, q, r *[3]uint) {
415 r[0], c = bits.Sub(p[0], q[0], c)
416 // amd64:"SBBQ",-"NEGL",-"NEGQ"
417 r[1], c = bits.Sub(p[1], q[1], c)
418 r[2], c = bits.Sub(p[2], q[2], c)
421 func Sub64(x, y, ci uint64) (r, co uint64) {
422 // amd64:"NEGL","SBBQ","NEGQ"
423 return bits.Sub64(x, y, ci)
426 func Sub64C(x, ci uint64) (r, co uint64) {
427 // amd64:"NEGL","SBBQ","NEGQ"
428 return bits.Sub64(x, 7, ci)
431 func Sub64Z(x, y uint64) (r, co uint64) {
432 // amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
433 return bits.Sub64(x, y, 0)
436 func Sub64R(x, y, ci uint64) uint64 {
437 // amd64:"NEGL","SBBQ",-"NEGQ"
438 r, _ := bits.Sub64(x, y, ci)
441 func Sub64M(p, q, r *[3]uint64) {
443 r[0], c = bits.Sub64(p[0], q[0], c)
444 // amd64:"SBBQ",-"NEGL",-"NEGQ"
445 r[1], c = bits.Sub64(p[1], q[1], c)
446 r[2], c = bits.Sub64(p[2], q[2], c)
449 // --------------- //
451 // --------------- //
453 func Mul(x, y uint) (hi, lo uint) {
455 // arm64:"UMULH","MUL"
456 // ppc64:"MULHDU","MULLD"
457 // ppc64le:"MULHDU","MULLD"
458 return bits.Mul(x, y)
461 func Mul64(x, y uint64) (hi, lo uint64) {
463 // arm64:"UMULH","MUL"
464 // ppc64:"MULHDU","MULLD"
465 // ppc64le:"MULHDU","MULLD"
466 return bits.Mul64(x, y)
469 // --------------- //
471 // --------------- //
473 func Div(hi, lo, x uint) (q, r uint) {
475 return bits.Div(hi, lo, x)
478 func Div64(hi, lo, x uint64) (q, r uint64) {
480 return bits.Div64(hi, lo, x)