fix(go.sum): update ResolveSpec dependency to v1.0.87
This commit is contained in:
Hein
+67
@@ -0,0 +1,67 @@
|
||||
package base64
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
)
|
||||
|
||||
const (
|
||||
StdPadding rune = base64.StdPadding
|
||||
NoPadding rune = base64.NoPadding
|
||||
|
||||
encodeStd = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"
|
||||
encodeURL = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789-_"
|
||||
encodeIMAP = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+,"
|
||||
|
||||
letterRange = int8('Z' - 'A' + 1)
|
||||
)
|
||||
|
||||
// StdEncoding is the standard base64 encoding, as defined in RFC 4648.
|
||||
var StdEncoding = NewEncoding(encodeStd)
|
||||
|
||||
// URLEncoding is the alternate base64 encoding defined in RFC 4648.
|
||||
// It is typically used in URLs and file names.
|
||||
var URLEncoding = NewEncoding(encodeURL)
|
||||
|
||||
// RawStdEncoding is the standard unpadded base64 encoding defined in RFC 4648 section 3.2.
|
||||
// This is the same as StdEncoding but omits padding characters.
|
||||
var RawStdEncoding = StdEncoding.WithPadding(NoPadding)
|
||||
|
||||
// RawURLEncoding is the unpadded alternate base64 encoding defined in RFC 4648.
|
||||
// This is the same as URLEncoding but omits padding characters.
|
||||
var RawURLEncoding = URLEncoding.WithPadding(NoPadding)
|
||||
|
||||
// NewEncoding returns a new padded Encoding defined by the given alphabet,
|
||||
// which must be a 64-byte string that does not contain the padding character
|
||||
// or CR / LF ('\r', '\n'). Unlike the standard library, the encoding alphabet
|
||||
// cannot be abitrary, and it must follow one of the know standard encoding
|
||||
// variants.
|
||||
//
|
||||
// Required alphabet values:
|
||||
// * [0,26): characters 'A'..'Z'
|
||||
// * [26,52): characters 'a'..'z'
|
||||
// * [52,62): characters '0'..'9'
|
||||
// Flexible alphabet value options:
|
||||
// * RFC 4648, RFC 1421, RFC 2045, RFC 2152, RFC 4880: '+' and '/'
|
||||
// * RFC 4648 URI: '-' and '_'
|
||||
// * RFC 3501: '+' and ','
|
||||
//
|
||||
// The resulting Encoding uses the default padding character ('='), which may
|
||||
// be changed or disabled via WithPadding. The padding characters is urestricted,
|
||||
// but it must be a character outside of the encoder alphabet.
|
||||
func NewEncoding(encoder string) *Encoding {
|
||||
if len(encoder) != 64 {
|
||||
panic("encoding alphabet is not 64-bytes long")
|
||||
}
|
||||
|
||||
if _, ok := allowedEncoding[encoder]; !ok {
|
||||
panic("non-standard encoding alphabets are not supported")
|
||||
}
|
||||
|
||||
return newEncoding(encoder)
|
||||
}
|
||||
|
||||
var allowedEncoding = map[string]struct{}{
|
||||
encodeStd: {},
|
||||
encodeURL: {},
|
||||
encodeIMAP: {},
|
||||
}
|
||||
+160
@@ -0,0 +1,160 @@
|
||||
//go:build amd64 && !purego
|
||||
// +build amd64,!purego
|
||||
|
||||
package base64
|
||||
|
||||
import (
|
||||
"encoding/base64"
|
||||
|
||||
"github.com/segmentio/asm/cpu"
|
||||
"github.com/segmentio/asm/cpu/x86"
|
||||
"github.com/segmentio/asm/internal/unsafebytes"
|
||||
)
|
||||
|
||||
// An Encoding is a radix 64 encoding/decoding scheme, defined by a
|
||||
// 64-character alphabet.
|
||||
type Encoding struct {
|
||||
enc func(dst []byte, src []byte, lut *int8) (int, int)
|
||||
enclut [32]int8
|
||||
|
||||
dec func(dst []byte, src []byte, lut *int8) (int, int)
|
||||
declut [48]int8
|
||||
|
||||
base *base64.Encoding
|
||||
}
|
||||
|
||||
const (
|
||||
minEncodeLen = 28
|
||||
minDecodeLen = 45
|
||||
)
|
||||
|
||||
func newEncoding(encoder string) *Encoding {
|
||||
e := &Encoding{base: base64.NewEncoding(encoder)}
|
||||
if cpu.X86.Has(x86.AVX2) {
|
||||
e.enableEncodeAVX2(encoder)
|
||||
e.enableDecodeAVX2(encoder)
|
||||
}
|
||||
return e
|
||||
}
|
||||
|
||||
func (e *Encoding) enableEncodeAVX2(encoder string) {
|
||||
// Translate values 0..63 to the Base64 alphabet. There are five sets:
|
||||
//
|
||||
// From To Add Index Example
|
||||
// [0..25] [65..90] +65 0 ABCDEFGHIJKLMNOPQRSTUVWXYZ
|
||||
// [26..51] [97..122] +71 1 abcdefghijklmnopqrstuvwxyz
|
||||
// [52..61] [48..57] -4 [2..11] 0123456789
|
||||
// [62] [43] -19 12 +
|
||||
// [63] [47] -16 13 /
|
||||
tab := [32]int8{int8(encoder[0]), int8(encoder[letterRange]) - letterRange}
|
||||
for i, ch := range encoder[2*letterRange:] {
|
||||
tab[2+i] = int8(ch) - 2*letterRange - int8(i)
|
||||
}
|
||||
|
||||
e.enc = encodeAVX2
|
||||
e.enclut = tab
|
||||
}
|
||||
|
||||
func (e *Encoding) enableDecodeAVX2(encoder string) {
|
||||
c62, c63 := int8(encoder[62]), int8(encoder[63])
|
||||
url := c63 == '_'
|
||||
if url {
|
||||
c63 = '/'
|
||||
}
|
||||
|
||||
// Translate values from the Base64 alphabet using five sets. Values outside
|
||||
// of these ranges are considered invalid:
|
||||
//
|
||||
// From To Add Index Example
|
||||
// [47] [63] +16 1 /
|
||||
// [43] [62] +19 2 +
|
||||
// [48..57] [52..61] +4 3 0123456789
|
||||
// [65..90] [0..25] -65 4,5 ABCDEFGHIJKLMNOPQRSTUVWXYZ
|
||||
// [97..122] [26..51] -71 6,7 abcdefghijklmnopqrstuvwxyz
|
||||
tab := [48]int8{
|
||||
0, 63 - c63, 62 - c62, 4, -65, -65, -71, -71,
|
||||
0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00, 0x00,
|
||||
0x15, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11, 0x11,
|
||||
0x11, 0x11, 0x13, 0x1B, 0x1B, 0x1B, 0x1B, 0x1B,
|
||||
}
|
||||
tab[(c62&15)+16] = 0x1A
|
||||
tab[(c63&15)+16] = 0x1A
|
||||
|
||||
if url {
|
||||
e.dec = decodeAVX2URI
|
||||
} else {
|
||||
e.dec = decodeAVX2
|
||||
}
|
||||
e.declut = tab
|
||||
}
|
||||
|
||||
// WithPadding creates a duplicate Encoding updated with a specified padding
|
||||
// character, or NoPadding to disable padding. The padding character must not
|
||||
// be contained in the encoding alphabet, must not be '\r' or '\n', and must
|
||||
// be no greater than '\xFF'.
|
||||
func (enc Encoding) WithPadding(padding rune) *Encoding {
|
||||
enc.base = enc.base.WithPadding(padding)
|
||||
return &enc
|
||||
}
|
||||
|
||||
// Strict creates a duplicate encoding updated with strict decoding enabled.
|
||||
// This requires that trailing padding bits are zero.
|
||||
func (enc Encoding) Strict() *Encoding {
|
||||
enc.base = enc.base.Strict()
|
||||
return &enc
|
||||
}
|
||||
|
||||
// Encode encodes src using the defined encoding alphabet.
|
||||
// This will write EncodedLen(len(src)) bytes to dst.
|
||||
func (enc *Encoding) Encode(dst, src []byte) {
|
||||
if len(src) >= minEncodeLen && enc.enc != nil {
|
||||
d, s := enc.enc(dst, src, &enc.enclut[0])
|
||||
dst = dst[d:]
|
||||
src = src[s:]
|
||||
}
|
||||
enc.base.Encode(dst, src)
|
||||
}
|
||||
|
||||
// Encode encodes src using the encoding enc, writing
|
||||
// EncodedLen(len(src)) bytes to dst.
|
||||
func (enc *Encoding) EncodeToString(src []byte) string {
|
||||
buf := make([]byte, enc.base.EncodedLen(len(src)))
|
||||
enc.Encode(buf, src)
|
||||
return string(buf)
|
||||
}
|
||||
|
||||
// EncodedLen calculates the base64-encoded byte length for a message
|
||||
// of length n.
|
||||
func (enc *Encoding) EncodedLen(n int) int {
|
||||
return enc.base.EncodedLen(n)
|
||||
}
|
||||
|
||||
// Decode decodes src using the defined encoding alphabet.
|
||||
// This will write DecodedLen(len(src)) bytes to dst and return the number of
|
||||
// bytes written.
|
||||
func (enc *Encoding) Decode(dst, src []byte) (n int, err error) {
|
||||
var d, s int
|
||||
if len(src) >= minDecodeLen && enc.dec != nil {
|
||||
d, s = enc.dec(dst, src, &enc.declut[0])
|
||||
dst = dst[d:]
|
||||
src = src[s:]
|
||||
}
|
||||
n, err = enc.base.Decode(dst, src)
|
||||
n += d
|
||||
return
|
||||
}
|
||||
|
||||
// DecodeString decodes the base64 encoded string s, returns the decoded
|
||||
// value as bytes.
|
||||
func (enc *Encoding) DecodeString(s string) ([]byte, error) {
|
||||
src := unsafebytes.BytesOf(s)
|
||||
dst := make([]byte, enc.base.DecodedLen(len(s)))
|
||||
n, err := enc.Decode(dst, src)
|
||||
return dst[:n], err
|
||||
}
|
||||
|
||||
// DecodedLen calculates the decoded byte length for a base64-encoded message
|
||||
// of length n.
|
||||
func (enc *Encoding) DecodedLen(n int) int {
|
||||
return enc.base.DecodedLen(n)
|
||||
}
|
||||
+14
@@ -0,0 +1,14 @@
|
||||
//go:build purego || !amd64
|
||||
// +build purego !amd64
|
||||
|
||||
package base64
|
||||
|
||||
import "encoding/base64"
|
||||
|
||||
// An Encoding is a radix 64 encoding/decoding scheme, defined by a
|
||||
// 64-character alphabet.
|
||||
type Encoding = base64.Encoding
|
||||
|
||||
func newEncoding(encoder string) *Encoding {
|
||||
return base64.NewEncoding(encoder)
|
||||
}
|
||||
+10
@@ -0,0 +1,10 @@
|
||||
// Code generated by command: go run decode_asm.go -pkg base64 -out ../base64/decode_amd64.s -stubs ../base64/decode_amd64.go. DO NOT EDIT.
|
||||
|
||||
//go:build !purego
|
||||
// +build !purego
|
||||
|
||||
package base64
|
||||
|
||||
func decodeAVX2(dst []byte, src []byte, lut *int8) (int, int)
|
||||
|
||||
func decodeAVX2URI(dst []byte, src []byte, lut *int8) (int, int)
|
||||
+144
@@ -0,0 +1,144 @@
|
||||
// Code generated by command: go run decode_asm.go -pkg base64 -out ../base64/decode_amd64.s -stubs ../base64/decode_amd64.go. DO NOT EDIT.
|
||||
|
||||
//go:build !purego
|
||||
// +build !purego
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
DATA b64_dec_lut_hi<>+0(SB)/8, $0x0804080402011010
|
||||
DATA b64_dec_lut_hi<>+8(SB)/8, $0x1010101010101010
|
||||
DATA b64_dec_lut_hi<>+16(SB)/8, $0x0804080402011010
|
||||
DATA b64_dec_lut_hi<>+24(SB)/8, $0x1010101010101010
|
||||
GLOBL b64_dec_lut_hi<>(SB), RODATA|NOPTR, $32
|
||||
|
||||
DATA b64_dec_madd1<>+0(SB)/8, $0x0140014001400140
|
||||
DATA b64_dec_madd1<>+8(SB)/8, $0x0140014001400140
|
||||
DATA b64_dec_madd1<>+16(SB)/8, $0x0140014001400140
|
||||
DATA b64_dec_madd1<>+24(SB)/8, $0x0140014001400140
|
||||
GLOBL b64_dec_madd1<>(SB), RODATA|NOPTR, $32
|
||||
|
||||
DATA b64_dec_madd2<>+0(SB)/8, $0x0001100000011000
|
||||
DATA b64_dec_madd2<>+8(SB)/8, $0x0001100000011000
|
||||
DATA b64_dec_madd2<>+16(SB)/8, $0x0001100000011000
|
||||
DATA b64_dec_madd2<>+24(SB)/8, $0x0001100000011000
|
||||
GLOBL b64_dec_madd2<>(SB), RODATA|NOPTR, $32
|
||||
|
||||
DATA b64_dec_shuf_lo<>+0(SB)/8, $0x0000000000000000
|
||||
DATA b64_dec_shuf_lo<>+8(SB)/8, $0x0600010200000000
|
||||
GLOBL b64_dec_shuf_lo<>(SB), RODATA|NOPTR, $16
|
||||
|
||||
DATA b64_dec_shuf<>+0(SB)/8, $0x090a040506000102
|
||||
DATA b64_dec_shuf<>+8(SB)/8, $0x000000000c0d0e08
|
||||
DATA b64_dec_shuf<>+16(SB)/8, $0x0c0d0e08090a0405
|
||||
DATA b64_dec_shuf<>+24(SB)/8, $0x0000000000000000
|
||||
GLOBL b64_dec_shuf<>(SB), RODATA|NOPTR, $32
|
||||
|
||||
// func decodeAVX2(dst []byte, src []byte, lut *int8) (int, int)
|
||||
// Requires: AVX, AVX2, SSE4.1
|
||||
TEXT ·decodeAVX2(SB), NOSPLIT, $0-72
|
||||
MOVQ dst_base+0(FP), AX
|
||||
MOVQ src_base+24(FP), DX
|
||||
MOVQ lut+48(FP), SI
|
||||
MOVQ src_len+32(FP), DI
|
||||
MOVB $0x2f, CL
|
||||
PINSRB $0x00, CX, X8
|
||||
VPBROADCASTB X8, Y8
|
||||
XORQ CX, CX
|
||||
XORQ BX, BX
|
||||
VPXOR Y7, Y7, Y7
|
||||
VPERMQ $0x44, (SI), Y6
|
||||
VPERMQ $0x44, 16(SI), Y4
|
||||
VMOVDQA b64_dec_lut_hi<>+0(SB), Y5
|
||||
|
||||
loop:
|
||||
VMOVDQU (DX)(BX*1), Y0
|
||||
VPSRLD $0x04, Y0, Y2
|
||||
VPAND Y8, Y0, Y3
|
||||
VPSHUFB Y3, Y4, Y3
|
||||
VPAND Y8, Y2, Y2
|
||||
VPSHUFB Y2, Y5, Y9
|
||||
VPTEST Y9, Y3
|
||||
JNE done
|
||||
VPCMPEQB Y8, Y0, Y3
|
||||
VPADDB Y3, Y2, Y2
|
||||
VPSHUFB Y2, Y6, Y2
|
||||
VPADDB Y0, Y2, Y0
|
||||
VPMADDUBSW b64_dec_madd1<>+0(SB), Y0, Y0
|
||||
VPMADDWD b64_dec_madd2<>+0(SB), Y0, Y0
|
||||
VEXTRACTI128 $0x01, Y0, X1
|
||||
VPSHUFB b64_dec_shuf_lo<>+0(SB), X1, X1
|
||||
VPSHUFB b64_dec_shuf<>+0(SB), Y0, Y0
|
||||
VPBLENDD $0x08, Y1, Y0, Y1
|
||||
VPBLENDD $0xc0, Y7, Y1, Y1
|
||||
VMOVDQU Y1, (AX)(CX*1)
|
||||
ADDQ $0x18, CX
|
||||
ADDQ $0x20, BX
|
||||
SUBQ $0x20, DI
|
||||
CMPQ DI, $0x2d
|
||||
JB done
|
||||
JMP loop
|
||||
|
||||
done:
|
||||
MOVQ CX, ret+56(FP)
|
||||
MOVQ BX, ret1+64(FP)
|
||||
VZEROUPPER
|
||||
RET
|
||||
|
||||
// func decodeAVX2URI(dst []byte, src []byte, lut *int8) (int, int)
|
||||
// Requires: AVX, AVX2, SSE4.1
|
||||
TEXT ·decodeAVX2URI(SB), NOSPLIT, $0-72
|
||||
MOVB $0x2f, AL
|
||||
PINSRB $0x00, AX, X0
|
||||
VPBROADCASTB X0, Y0
|
||||
MOVB $0x5f, AL
|
||||
PINSRB $0x00, AX, X1
|
||||
VPBROADCASTB X1, Y1
|
||||
MOVQ dst_base+0(FP), AX
|
||||
MOVQ src_base+24(FP), DX
|
||||
MOVQ lut+48(FP), SI
|
||||
MOVQ src_len+32(FP), DI
|
||||
MOVB $0x2f, CL
|
||||
PINSRB $0x00, CX, X10
|
||||
VPBROADCASTB X10, Y10
|
||||
XORQ CX, CX
|
||||
XORQ BX, BX
|
||||
VPXOR Y9, Y9, Y9
|
||||
VPERMQ $0x44, (SI), Y8
|
||||
VPERMQ $0x44, 16(SI), Y6
|
||||
VMOVDQA b64_dec_lut_hi<>+0(SB), Y7
|
||||
|
||||
loop:
|
||||
VMOVDQU (DX)(BX*1), Y2
|
||||
VPCMPEQB Y2, Y1, Y4
|
||||
VPBLENDVB Y4, Y0, Y2, Y2
|
||||
VPSRLD $0x04, Y2, Y4
|
||||
VPAND Y10, Y2, Y5
|
||||
VPSHUFB Y5, Y6, Y5
|
||||
VPAND Y10, Y4, Y4
|
||||
VPSHUFB Y4, Y7, Y11
|
||||
VPTEST Y11, Y5
|
||||
JNE done
|
||||
VPCMPEQB Y10, Y2, Y5
|
||||
VPADDB Y5, Y4, Y4
|
||||
VPSHUFB Y4, Y8, Y4
|
||||
VPADDB Y2, Y4, Y2
|
||||
VPMADDUBSW b64_dec_madd1<>+0(SB), Y2, Y2
|
||||
VPMADDWD b64_dec_madd2<>+0(SB), Y2, Y2
|
||||
VEXTRACTI128 $0x01, Y2, X3
|
||||
VPSHUFB b64_dec_shuf_lo<>+0(SB), X3, X3
|
||||
VPSHUFB b64_dec_shuf<>+0(SB), Y2, Y2
|
||||
VPBLENDD $0x08, Y3, Y2, Y3
|
||||
VPBLENDD $0xc0, Y9, Y3, Y3
|
||||
VMOVDQU Y3, (AX)(CX*1)
|
||||
ADDQ $0x18, CX
|
||||
ADDQ $0x20, BX
|
||||
SUBQ $0x20, DI
|
||||
CMPQ DI, $0x2d
|
||||
JB done
|
||||
JMP loop
|
||||
|
||||
done:
|
||||
MOVQ CX, ret+56(FP)
|
||||
MOVQ BX, ret1+64(FP)
|
||||
VZEROUPPER
|
||||
RET
|
||||
+8
@@ -0,0 +1,8 @@
|
||||
// Code generated by command: go run encode_asm.go -pkg base64 -out ../base64/encode_amd64.s -stubs ../base64/encode_amd64.go. DO NOT EDIT.
|
||||
|
||||
//go:build !purego
|
||||
// +build !purego
|
||||
|
||||
package base64
|
||||
|
||||
func encodeAVX2(dst []byte, src []byte, lut *int8) (int, int)
|
||||
+88
@@ -0,0 +1,88 @@
|
||||
// Code generated by command: go run encode_asm.go -pkg base64 -out ../base64/encode_amd64.s -stubs ../base64/encode_amd64.go. DO NOT EDIT.
|
||||
|
||||
//go:build !purego
|
||||
// +build !purego
|
||||
|
||||
#include "textflag.h"
|
||||
|
||||
// func encodeAVX2(dst []byte, src []byte, lut *int8) (int, int)
|
||||
// Requires: AVX, AVX2, SSE4.1
|
||||
TEXT ·encodeAVX2(SB), NOSPLIT, $0-72
|
||||
MOVQ dst_base+0(FP), AX
|
||||
MOVQ src_base+24(FP), DX
|
||||
MOVQ lut+48(FP), SI
|
||||
MOVQ src_len+32(FP), DI
|
||||
MOVB $0x33, CL
|
||||
PINSRB $0x00, CX, X4
|
||||
VPBROADCASTB X4, Y4
|
||||
MOVB $0x19, CL
|
||||
PINSRB $0x00, CX, X5
|
||||
VPBROADCASTB X5, Y5
|
||||
XORQ CX, CX
|
||||
XORQ BX, BX
|
||||
|
||||
// Load the 16-byte LUT into both lanes of the register
|
||||
VPERMQ $0x44, (SI), Y3
|
||||
|
||||
// Load the first block using a mask to avoid potential fault
|
||||
VMOVDQU b64_enc_load<>+0(SB), Y0
|
||||
VPMASKMOVD -4(DX)(BX*1), Y0, Y0
|
||||
|
||||
loop:
|
||||
VPSHUFB b64_enc_shuf<>+0(SB), Y0, Y0
|
||||
VPAND b64_enc_mask1<>+0(SB), Y0, Y1
|
||||
VPSLLW $0x08, Y1, Y2
|
||||
VPSLLW $0x04, Y1, Y1
|
||||
VPBLENDW $0xaa, Y2, Y1, Y2
|
||||
VPAND b64_enc_mask2<>+0(SB), Y0, Y1
|
||||
VPMULHUW b64_enc_mult<>+0(SB), Y1, Y0
|
||||
VPOR Y0, Y2, Y0
|
||||
VPSUBUSB Y4, Y0, Y1
|
||||
VPCMPGTB Y5, Y0, Y2
|
||||
VPSUBB Y2, Y1, Y1
|
||||
VPSHUFB Y1, Y3, Y1
|
||||
VPADDB Y0, Y1, Y0
|
||||
VMOVDQU Y0, (AX)(CX*1)
|
||||
ADDQ $0x20, CX
|
||||
ADDQ $0x18, BX
|
||||
SUBQ $0x18, DI
|
||||
CMPQ DI, $0x20
|
||||
JB done
|
||||
VMOVDQU -4(DX)(BX*1), Y0
|
||||
JMP loop
|
||||
|
||||
done:
|
||||
MOVQ CX, ret+56(FP)
|
||||
MOVQ BX, ret1+64(FP)
|
||||
VZEROUPPER
|
||||
RET
|
||||
|
||||
DATA b64_enc_load<>+0(SB)/8, $0x8000000000000000
|
||||
DATA b64_enc_load<>+8(SB)/8, $0x8000000080000000
|
||||
DATA b64_enc_load<>+16(SB)/8, $0x8000000080000000
|
||||
DATA b64_enc_load<>+24(SB)/8, $0x8000000080000000
|
||||
GLOBL b64_enc_load<>(SB), RODATA|NOPTR, $32
|
||||
|
||||
DATA b64_enc_shuf<>+0(SB)/8, $0x0809070805060405
|
||||
DATA b64_enc_shuf<>+8(SB)/8, $0x0e0f0d0e0b0c0a0b
|
||||
DATA b64_enc_shuf<>+16(SB)/8, $0x0405030401020001
|
||||
DATA b64_enc_shuf<>+24(SB)/8, $0x0a0b090a07080607
|
||||
GLOBL b64_enc_shuf<>(SB), RODATA|NOPTR, $32
|
||||
|
||||
DATA b64_enc_mask1<>+0(SB)/8, $0x003f03f0003f03f0
|
||||
DATA b64_enc_mask1<>+8(SB)/8, $0x003f03f0003f03f0
|
||||
DATA b64_enc_mask1<>+16(SB)/8, $0x003f03f0003f03f0
|
||||
DATA b64_enc_mask1<>+24(SB)/8, $0x003f03f0003f03f0
|
||||
GLOBL b64_enc_mask1<>(SB), RODATA|NOPTR, $32
|
||||
|
||||
DATA b64_enc_mask2<>+0(SB)/8, $0x0fc0fc000fc0fc00
|
||||
DATA b64_enc_mask2<>+8(SB)/8, $0x0fc0fc000fc0fc00
|
||||
DATA b64_enc_mask2<>+16(SB)/8, $0x0fc0fc000fc0fc00
|
||||
DATA b64_enc_mask2<>+24(SB)/8, $0x0fc0fc000fc0fc00
|
||||
GLOBL b64_enc_mask2<>(SB), RODATA|NOPTR, $32
|
||||
|
||||
DATA b64_enc_mult<>+0(SB)/8, $0x0400004004000040
|
||||
DATA b64_enc_mult<>+8(SB)/8, $0x0400004004000040
|
||||
DATA b64_enc_mult<>+16(SB)/8, $0x0400004004000040
|
||||
DATA b64_enc_mult<>+24(SB)/8, $0x0400004004000040
|
||||
GLOBL b64_enc_mult<>(SB), RODATA|NOPTR, $32
|
||||
Reference in New Issue
Block a user