Source file src/pkg/vendor/golang.org/x/sys/cpu/cpu_linux_s390x.go

     1	// Copyright 2019 The Go Authors. All rights reserved.
     2	// Use of this source code is governed by a BSD-style
     3	// license that can be found in the LICENSE file.
     4	
     5	package cpu
     6	
     7	const cacheLineSize = 256
     8	
     9	const (
    10		// bit mask values from /usr/include/bits/hwcap.h
    11		hwcap_ZARCH  = 2
    12		hwcap_STFLE  = 4
    13		hwcap_MSA    = 8
    14		hwcap_LDISP  = 16
    15		hwcap_EIMM   = 32
    16		hwcap_DFP    = 64
    17		hwcap_ETF3EH = 256
    18		hwcap_VX     = 2048
    19		hwcap_VXE    = 8192
    20	)
    21	
    22	// bitIsSet reports whether the bit at index is set. The bit index
    23	// is in big endian order, so bit index 0 is the leftmost bit.
    24	func bitIsSet(bits []uint64, index uint) bool {
    25		return bits[index/64]&((1<<63)>>(index%64)) != 0
    26	}
    27	
    28	// function is the code for the named cryptographic function.
    29	type function uint8
    30	
    31	const (
    32		// KM{,A,C,CTR} function codes
    33		aes128 function = 18 // AES-128
    34		aes192 function = 19 // AES-192
    35		aes256 function = 20 // AES-256
    36	
    37		// K{I,L}MD function codes
    38		sha1     function = 1  // SHA-1
    39		sha256   function = 2  // SHA-256
    40		sha512   function = 3  // SHA-512
    41		sha3_224 function = 32 // SHA3-224
    42		sha3_256 function = 33 // SHA3-256
    43		sha3_384 function = 34 // SHA3-384
    44		sha3_512 function = 35 // SHA3-512
    45		shake128 function = 36 // SHAKE-128
    46		shake256 function = 37 // SHAKE-256
    47	
    48		// KLMD function codes
    49		ghash function = 65 // GHASH
    50	)
    51	
    52	// queryResult contains the result of a Query function
    53	// call. Bits are numbered in big endian order so the
    54	// leftmost bit (the MSB) is at index 0.
    55	type queryResult struct {
    56		bits [2]uint64
    57	}
    58	
    59	// Has reports whether the given functions are present.
    60	func (q *queryResult) Has(fns ...function) bool {
    61		if len(fns) == 0 {
    62			panic("no function codes provided")
    63		}
    64		for _, f := range fns {
    65			if !bitIsSet(q.bits[:], uint(f)) {
    66				return false
    67			}
    68		}
    69		return true
    70	}
    71	
    72	// facility is a bit index for the named facility.
    73	type facility uint8
    74	
    75	const (
    76		// cryptography facilities
    77		msa4 facility = 77  // message-security-assist extension 4
    78		msa8 facility = 146 // message-security-assist extension 8
    79	)
    80	
    81	// facilityList contains the result of an STFLE call.
    82	// Bits are numbered in big endian order so the
    83	// leftmost bit (the MSB) is at index 0.
    84	type facilityList struct {
    85		bits [4]uint64
    86	}
    87	
    88	// Has reports whether the given facilities are present.
    89	func (s *facilityList) Has(fs ...facility) bool {
    90		if len(fs) == 0 {
    91			panic("no facility bits provided")
    92		}
    93		for _, f := range fs {
    94			if !bitIsSet(s.bits[:], uint(f)) {
    95				return false
    96			}
    97		}
    98		return true
    99	}
   100	
   101	func doinit() {
   102		// test HWCAP bit vector
   103		has := func(featureMask uint) bool {
   104			return hwCap&featureMask == featureMask
   105		}
   106	
   107		// mandatory
   108		S390X.HasZARCH = has(hwcap_ZARCH)
   109	
   110		// optional
   111		S390X.HasSTFLE = has(hwcap_STFLE)
   112		S390X.HasLDISP = has(hwcap_LDISP)
   113		S390X.HasEIMM = has(hwcap_EIMM)
   114		S390X.HasETF3EH = has(hwcap_ETF3EH)
   115		S390X.HasDFP = has(hwcap_DFP)
   116		S390X.HasMSA = has(hwcap_MSA)
   117		S390X.HasVX = has(hwcap_VX)
   118		if S390X.HasVX {
   119			S390X.HasVXE = has(hwcap_VXE)
   120		}
   121	
   122		// We need implementations of stfle, km and so on
   123		// to detect cryptographic features.
   124		if !haveAsmFunctions() {
   125			return
   126		}
   127	
   128		// optional cryptographic functions
   129		if S390X.HasMSA {
   130			aes := []function{aes128, aes192, aes256}
   131	
   132			// cipher message
   133			km, kmc := kmQuery(), kmcQuery()
   134			S390X.HasAES = km.Has(aes...)
   135			S390X.HasAESCBC = kmc.Has(aes...)
   136			if S390X.HasSTFLE {
   137				facilities := stfle()
   138				if facilities.Has(msa4) {
   139					kmctr := kmctrQuery()
   140					S390X.HasAESCTR = kmctr.Has(aes...)
   141				}
   142				if facilities.Has(msa8) {
   143					kma := kmaQuery()
   144					S390X.HasAESGCM = kma.Has(aes...)
   145				}
   146			}
   147	
   148			// compute message digest
   149			kimd := kimdQuery() // intermediate (no padding)
   150			klmd := klmdQuery() // last (padding)
   151			S390X.HasSHA1 = kimd.Has(sha1) && klmd.Has(sha1)
   152			S390X.HasSHA256 = kimd.Has(sha256) && klmd.Has(sha256)
   153			S390X.HasSHA512 = kimd.Has(sha512) && klmd.Has(sha512)
   154			S390X.HasGHASH = kimd.Has(ghash) // KLMD-GHASH does not exist
   155			sha3 := []function{
   156				sha3_224, sha3_256, sha3_384, sha3_512,
   157				shake128, shake256,
   158			}
   159			S390X.HasSHA3 = kimd.Has(sha3...) && klmd.Has(sha3...)
   160		}
   161	}
   162	

View as plain text