.config/coc/extensions/coc-go-data/tools/pkg/mod/golang.org/x/sys@v0.0.0-20210124154548-22da62e12c0c/cpu/cpu_netbsd_arm64.go

   1 // Copyright 2020 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 import (
   8         "syscall"
   9         "unsafe"
  10 )
  11
  12 // Minimal copy of functionality from x/sys/unix so the cpu package can call
  13 // sysctl without depending on x/sys/unix.
  14
  15 const (
  16         _CTL_QUERY = -2
  17
  18         _SYSCTL_VERS_1 = 0x1000000
  19 )
  20
  21 var _zero uintptr
  22
  23 func sysctl(mib []int32, old *byte, oldlen *uintptr, new *byte, newlen uintptr) (err error) {
  24         var _p0 unsafe.Pointer
  25         if len(mib) > 0 {
  26                 _p0 = unsafe.Pointer(&mib[0])
  27         } else {
  28                 _p0 = unsafe.Pointer(&_zero)
  29         }
  30         _, _, errno := syscall.Syscall6(
  31                 syscall.SYS___SYSCTL,
  32                 uintptr(_p0),
  33                 uintptr(len(mib)),
  34                 uintptr(unsafe.Pointer(old)),
  35                 uintptr(unsafe.Pointer(oldlen)),
  36                 uintptr(unsafe.Pointer(new)),
  37                 uintptr(newlen))
  38         if errno != 0 {
  39                 return errno
  40         }
  41         return nil
  42 }
  43
  44 type sysctlNode struct {
  45         Flags          uint32
  46         Num            int32
  47         Name           [32]int8
  48         Ver            uint32
  49         __rsvd         uint32
  50         Un             [16]byte
  51         _sysctl_size   [8]byte
  52         _sysctl_func   [8]byte
  53         _sysctl_parent [8]byte
  54         _sysctl_desc   [8]byte
  55 }
  56
  57 func sysctlNodes(mib []int32) ([]sysctlNode, error) {
  58         var olen uintptr
  59
  60         // Get a list of all sysctl nodes below the given MIB by performing
  61         // a sysctl for the given MIB with CTL_QUERY appended.
  62         mib = append(mib, _CTL_QUERY)
  63         qnode := sysctlNode{Flags: _SYSCTL_VERS_1}
  64         qp := (*byte)(unsafe.Pointer(&qnode))
  65         sz := unsafe.Sizeof(qnode)
  66         if err := sysctl(mib, nil, &olen, qp, sz); err != nil {
  67                 return nil, err
  68         }
  69
  70         // Now that we know the size, get the actual nodes.
  71         nodes := make([]sysctlNode, olen/sz)
  72         np := (*byte)(unsafe.Pointer(&nodes[0]))
  73         if err := sysctl(mib, np, &olen, qp, sz); err != nil {
  74                 return nil, err
  75         }
  76
  77         return nodes, nil
  78 }
  79
  80 func nametomib(name string) ([]int32, error) {
  81         // Split name into components.
  82         var parts []string
  83         last := 0
  84         for i := 0; i < len(name); i++ {
  85                 if name[i] == '.' {
  86                         parts = append(parts, name[last:i])
  87                         last = i + 1
  88                 }
  89         }
  90         parts = append(parts, name[last:])
  91
  92         mib := []int32{}
  93         // Discover the nodes and construct the MIB OID.
  94         for partno, part := range parts {
  95                 nodes, err := sysctlNodes(mib)
  96                 if err != nil {
  97                         return nil, err
  98                 }
  99                 for _, node := range nodes {
 100                         n := make([]byte, 0)
 101                         for i := range node.Name {
 102                                 if node.Name[i] != 0 {
 103                                         n = append(n, byte(node.Name[i]))
 104                                 }
 105                         }
 106                         if string(n) == part {
 107                                 mib = append(mib, int32(node.Num))
 108                                 break
 109                         }
 110                 }
 111                 if len(mib) != partno+1 {
 112                         return nil, err
 113                 }
 114         }
 115
 116         return mib, nil
 117 }
 118
 119 // aarch64SysctlCPUID is struct aarch64_sysctl_cpu_id from NetBSD's <aarch64/armreg.h>
 120 type aarch64SysctlCPUID struct {
 121         midr      uint64 /* Main ID Register */
 122         revidr    uint64 /* Revision ID Register */
 123         mpidr     uint64 /* Multiprocessor Affinity Register */
 124         aa64dfr0  uint64 /* A64 Debug Feature Register 0 */
 125         aa64dfr1  uint64 /* A64 Debug Feature Register 1 */
 126         aa64isar0 uint64 /* A64 Instruction Set Attribute Register 0 */
 127         aa64isar1 uint64 /* A64 Instruction Set Attribute Register 1 */
 128         aa64mmfr0 uint64 /* A64 Memory Model Feature Register 0 */
 129         aa64mmfr1 uint64 /* A64 Memory Model Feature Register 1 */
 130         aa64mmfr2 uint64 /* A64 Memory Model Feature Register 2 */
 131         aa64pfr0  uint64 /* A64 Processor Feature Register 0 */
 132         aa64pfr1  uint64 /* A64 Processor Feature Register 1 */
 133         aa64zfr0  uint64 /* A64 SVE Feature ID Register 0 */
 134         mvfr0     uint32 /* Media and VFP Feature Register 0 */
 135         mvfr1     uint32 /* Media and VFP Feature Register 1 */
 136         mvfr2     uint32 /* Media and VFP Feature Register 2 */
 137         pad       uint32
 138         clidr     uint64 /* Cache Level ID Register */
 139         ctr       uint64 /* Cache Type Register */
 140 }
 141
 142 func sysctlCPUID(name string) (*aarch64SysctlCPUID, error) {
 143         mib, err := nametomib(name)
 144         if err != nil {
 145                 return nil, err
 146         }
 147
 148         out := aarch64SysctlCPUID{}
 149         n := unsafe.Sizeof(out)
 150         _, _, errno := syscall.Syscall6(
 151                 syscall.SYS___SYSCTL,
 152                 uintptr(unsafe.Pointer(&mib[0])),
 153                 uintptr(len(mib)),
 154                 uintptr(unsafe.Pointer(&out)),
 155                 uintptr(unsafe.Pointer(&n)),
 156                 uintptr(0),
 157                 uintptr(0))
 158         if errno != 0 {
 159                 return nil, errno
 160         }
 161         return &out, nil
 162 }
 163
 164 func doinit() {
 165         cpuid, err := sysctlCPUID("machdep.cpu0.cpu_id")
 166         if err != nil {
 167                 setMinimalFeatures()
 168                 return
 169         }
 170         parseARM64SystemRegisters(cpuid.aa64isar0, cpuid.aa64isar1, cpuid.aa64pfr0)
 171
 172         Initialized = true
 173 }