aboutsummaryrefslogtreecommitdiffstats
path: root/pow/xor.go
blob: 558aeb469077ed8ac66235729fa1934a40be5ff9 (plain) (blame)
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
// Copyright 2013 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
// license that can be found in the LICENSE file.

// Source: https://golang.org/src/crypto/cipher/xor.go

package pow

import (
    "runtime"
    "unsafe"
)

const wordSize = int(unsafe.Sizeof(uintptr(0)))
const supportsUnaligned = runtime.GOARCH == "386" || runtime.GOARCH == "amd64" || runtime.GOARCH == "ppc64" || runtime.GOARCH == "ppc64le" || runtime.GOARCH == "s390x"

// fastXORBytes xors in bulk. It only works on architectures that
// support unaligned read/writes.
func fastXORBytes(dst, a, b []byte) int {
    n := len(a)
    if len(b) < n {
        n = len(b)
    }

    w := n / wordSize
    if w > 0 {
        dw := *(*[]uintptr)(unsafe.Pointer(&dst))
        aw := *(*[]uintptr)(unsafe.Pointer(&a))
        bw := *(*[]uintptr)(unsafe.Pointer(&b))
        for i := 0; i < w; i++ {
            dw[i] = aw[i] ^ bw[i]
        }
    }

    for i := (n - n%wordSize); i < n; i++ {
        dst[i] = a[i] ^ b[i]
    }

    return n
}

func safeXORBytes(dst, a, b []byte) int {
    n := len(a)
    if len(b) < n {
        n = len(b)
    }
    for i := 0; i < n; i++ {
        dst[i] = a[i] ^ b[i]
    }
    return n
}

// xorBytes xors the bytes in a and b. The destination is assumed to have enough
// space. Returns the number of bytes xor'd.
func xorBytes(dst, a, b []byte) int {
    if supportsUnaligned {
        return fastXORBytes(dst, a, b)
    }
    // TODO(hanwen): if (dst, a, b) have common alignment
    // we could still try fastXORBytes. It is not clear
    // how often this happens, and it's only worth it if
    // the block encryption itself is hardware
    // accelerated.
    return safeXORBytes(dst, a, b)
}

// fastXORWords XORs multiples of 4 or 8 bytes (depending on architecture.)
// The arguments are assumed to be of equal length.
func fastXORWords(dst, a, b []byte) {
    dw := *(*[]uintptr)(unsafe.Pointer(&dst))
    aw := *(*[]uintptr)(unsafe.Pointer(&a))
    bw := *(*[]uintptr)(unsafe.Pointer(&b))
    n := len(b) / wordSize
    for i := 0; i < n; i++ {
        dw[i] = aw[i] ^ bw[i]
    }
}

func xorWords(dst, a, b []byte) {
    if supportsUnaligned {
        fastXORWords(dst, a, b)
    } else {
        safeXORBytes(dst, a, b)
    }
}