Skip to content
New issue

Have a question about this project? Sign up for a free GitHub account to open an issue and contact its maintainers and the community.

By clicking “Sign up for GitHub”, you agree to our terms of service and privacy statement. We’ll occasionally send you account related emails.

Already on GitHub? Sign in to your account

cmd/compile: loads/constants not lifted out of loop #15808

Open
randall77 opened this issue May 24, 2016 · 44 comments
Open

cmd/compile: loads/constants not lifted out of loop #15808

randall77 opened this issue May 24, 2016 · 44 comments
Assignees
Milestone

Comments

@randall77
Copy link
Contributor

@randall77 randall77 commented May 24, 2016

var t [256]byte

func f(b *[16]byte) {
    for i, v := range b {
        b[i] = t[v]
    }
}

Compiles to:

    0x000f 00015 (tmp1.go:7)    MOVBLZX (AX), DX
    0x0012 00018 (tmp1.go:7)    LEAQ    "".t(SB), BX
    0x0019 00025 (tmp1.go:7)    MOVBLZX (BX)(DX*1), DX
    0x001d 00029 (tmp1.go:7)    MOVQ    "".b+8(FP), BX
    0x0022 00034 (tmp1.go:7)    MOVB    DL, (BX)(CX*1)
    0x0025 00037 (tmp1.go:6)    INCQ    AX
    0x0028 00040 (tmp1.go:6)    INCQ    CX
    0x002b 00043 (tmp1.go:6)    CMPQ    CX, $16
    0x002f 00047 (tmp1.go:6)    JLT $0, 15

Both the LEAQ and the MOVQ "".b+8 could be done outside the loop.

@randall77 randall77 added this to the Go1.8 milestone May 24, 2016
@dr2chase dr2chase self-assigned this May 24, 2016
@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented May 24, 2016

Happy to work on this; I prototyped a loop-invariant code hoister and tried it out, but it didn't (at the time) do anything exciting for performance on amd64. Note that this can increase register pressure.

@randall77
Copy link
Contributor Author

@randall77 randall77 commented May 24, 2016

I thought the register allocator pre-allocated things like this before loop entry. I suspect that something is not working about that code, not that we need a whole new pass. (Not that a code hoister is a bad idea, just that it may not be needed for this issue.)

@mattn
Copy link
Member

@mattn mattn commented Aug 4, 2016

If overwriting t in goroutine, the loop should refer the new t. So need to LEAQ is required in this loop. If the loop-count is large enough, below should remove the LEAQ in the loop.

func f(b []byte) {
    t := t // THIS
    for i := 0; i < 100000000; i++ {
        b[i%len(b)] = t[i%len(t)]
    }
}
@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented Feb 22, 2017

I just revived my old loop-invariant-code experiment, and here's a (very) preliminary result.
CL here: https://go-review.googlesource.com/37338
I'm doing no transformations, just looking at what I might change. To note:

(1) this pushes "loop-invariant" till it finds them all.
(2) anything depending on a store is loop-variant.
(3) anything depending on a phi is loop-variant (this is a little wimpy).
(4) anything rematerializable is considered uninteresting (for reporting purposes)
(5) innermost loops only.
(6) must-execute blocks only.
(6) haven't thought/worried about problem of hoisting things that fault (like division)
(7) there's loop-invariant control flow in there we might want to think about.

##### Building packages and commands for darwin/amd64.
runtime/internal/sys
runtime/internal/atomic
runtime
# runtime
runtime/cgocheck.go:144: Inner loop invariant, header b38, val v283 = ADDQ <uintptr> v426 v10, func cgoCheckTypedBlock
runtime/hashmap.go:273: Inner loop invariant, header b48, val v277 = CMPQconst <flags> [8] v10, func makemap
runtime/hashmap.go:273: Inner loop invariant, header b48, val v331 = CVTSQ2SS <float32> v10, func makemap
runtime/heapdump.go:165: Inner loop invariant, header b6, val v35 = LEAQ1 <*[4]*_type> v9 v98, func dumptype
runtime/heapdump.go:178: Inner loop invariant, header b22, val v86 = LEAQ1 <*[4]*_type> v9 v98, func dumptype
runtime/mbitmap.go:645: Inner loop invariant, header b4, val v97 = TESTQ <flags> v10 v10, func bulkBarrierBitmap
runtime/mbitmap.go:766: Inner loop invariant, header b11, val v99 = SHRQconst <uintptr> [3] v9, func heapBits.initCheckmarkSpan
runtime/mbitmap.go:1488: Inner loop invariant, header b7, val v735 = CMPQconst <flags> [1] v12, func runGCProg
runtime/mbitmap.go:1524: Inner loop invariant, header b28, val v769 = CMPQconst <flags> [64] v14, func runGCProg
runtime/mbitmap.go:1524: Inner loop invariant, header b28, val v607 = SBBQcarrymask <uintptr> v769, func runGCProg
runtime/mbitmap.go:1526: Inner loop invariant, header b28, val v1028 = CMPQconst <flags> [1] v12, func runGCProg
runtime/mbitmap.go:1695: Inner loop invariant, header b132, val v1157 = CMPQconst <flags> [64] v938, func runGCProg
runtime/mbitmap.go:1695: Inner loop invariant, header b132, val v1312 = SBBQcarrymask <uintptr> v1157, func runGCProg
runtime/mbitmap.go:1718: Inner loop invariant, header b148, val v856 = CMPQconst <flags> [64] v895, func runGCProg
runtime/mbitmap.go:1718: Inner loop invariant, header b148, val v1004 = SBBQcarrymask <uintptr> v856, func runGCProg
runtime/mcentral.go:45: Inner loop invariant, header b5, val v53 = ADDLconst <uint32> [-2] v37, func (*mcentral).cacheSpan
runtime/mcentral.go:45: Inner loop invariant, header b5, val v62 = ADDLconst <uint32> [-1] v37, func (*mcentral).cacheSpan
runtime/mcentral.go:52: Inner loop invariant, header b5, val v102 = ADDLconst <uint32> [-1] v37, func (*mcentral).cacheSpan
runtime/mcentral.go:64: Inner loop invariant, header b16, val v145 = ADDLconst <uint32> [-2] v37, func (*mcentral).cacheSpan
runtime/mcentral.go:64: Inner loop invariant, header b16, val v153 = ADDLconst <uint32> [-1] v37, func (*mcentral).cacheSpan
runtime/mcentral.go:82: Inner loop invariant, header b16, val v214 = ADDLconst <uint32> [-1] v37, func (*mcentral).cacheSpan
runtime/mgc.go:943: Inner loop invariant, header b16, val v245 = TESTQ <flags> v6 v6, func gcStart
runtime/mgc.go:1471: Inner loop invariant, header b10, val v96 = ADDQconst <*guintptr> [4632] v5, func gcBgMarkWorker
runtime/mgc.go:1521: Inner loop invariant, header b10, val v216 = ADDQconst <*gcWork> [4648] v5, func gcBgMarkWorker
runtime/mgcmark.go:195: Inner loop invariant, header b32, val v125 = MOVLQZX <int> v124, func markroot
runtime/mgcmark.go:195: Inner loop invariant, header b32, val v124 = SUBL <uint32> v7 v13, func markroot
runtime/mgcmark.go:200: Inner loop invariant, header b41, val v187 = MOVLQZX <int> v186, func markroot
runtime/mgcmark.go:200: Inner loop invariant, header b41, val v186 = SUBL <uint32> v7 v18, func markroot
runtime/mgcmark.go:426: Inner loop invariant, header b9, val v58 = CVTSQ2SD <float64> v52, func gcAssistAlloc
runtime/mgcmark.go:466: Inner loop invariant, header b9, val v145 = ADDQconst <*unsafe.Pointer> [136] v5, func gcAssistAlloc
runtime/mgcmark.go:1305: Inner loop invariant, header b20, val v238 = ADDQconst <uintptr> [-128] v9, func gcDumpObject
runtime/mgcmark.go:1305: Inner loop invariant, header b20, val v243 = ADDQconst <uintptr> [128] v9, func gcDumpObject
runtime/mgcsweep.go:87: Inner loop invariant, header b3, val v29 = MOVLQZX <int> v28, func sweepone
runtime/mgcsweep.go:87: Inner loop invariant, header b3, val v200 = CMPQconst <flags> [2] v29, func sweepone
runtime/mgcsweep.go:87: Inner loop invariant, header b3, val v142 = LEAQ4 <int> v29 v29, func sweepone
runtime/mgcsweep.go:87: Inner loop invariant, header b3, val v38 = LEAQ8 <*uint32> [4224] v18 v142, func sweepone
runtime/mgcsweep.go:87: Inner loop invariant, header b3, val v270 = SHRLconst <uint32> [1] v20, func sweepone
runtime/mgcsweep.go:87: Inner loop invariant, header b3, val v27 = ANDLconst <uint32> [1] v270, func sweepone
runtime/mgcsweep.go:87: Inner loop invariant, header b3, val v150 = ADDLconst <uint32> [-1] v27, func sweepone
runtime/mgcsweep.go:87: Inner loop invariant, header b3, val v28 = NEGL <uint32> v150, func sweepone
runtime/mgcsweep.go:235: Inner loop invariant, header b38, val v272 = TESTB <flags> v1289 v1289, func (*mspan).sweep
runtime/mheap.go:466: Inner loop invariant, header b3, val v30 = ADDLconst <uint32> [-2] v14, func (*mheap).reclaimList
runtime/mheap.go:466: Inner loop invariant, header b3, val v39 = ADDLconst <uint32> [-1] v14, func (*mheap).reclaimList
runtime/mheap.go:482: Inner loop invariant, header b3, val v98 = ADDLconst <uint32> [-1] v14, func (*mheap).reclaimList
runtime/mprof.go:442: Inner loop invariant, header b24, val v162 = TESTB <flags> v9 v9, func MemProfile
runtime/mprof.go:442: Inner loop invariant, header b14, val v8 = TESTB <flags> v9 v9, func MemProfile
runtime/mprof.go:442: Inner loop invariant, header b2, val v156 = TESTB <flags> v9 v9, func MemProfile
runtime/netpoll.go:174: Inner loop invariant, header b15, val v106 = CMPLconst <flags> [119] v8, func poll_runtime_pollWait
runtime/netpoll.go:376: Inner loop invariant, header b5, val v53 = TESTB <flags> v10 v10, func netpollunblock
runtime/netpoll.go:396: Inner loop invariant, header b5, val v39 = MOVBQZX <uintptr> v10, func netpollunblock
runtime/netpoll_kqueue.go:88: Inner loop invariant, header b11, val v96 = MOVLQSX <int> v53, func netpoll
runtime/panic.go:351: Inner loop invariant, header b3, val v8 = ADDQconst <**_defer> [40] v4, func Goexit
runtime/panic.go:460: Inner loop invariant, header b15, val v217 = ADDQconst <**_defer> [40] v6, func gopanic
runtime/proc.go:1556: Inner loop invariant, header b3, val v60 = TESTB <flags> v6 v6, func lockextra
runtime/proc.go:1963: Inner loop invariant, header b58, val v328 = SETG <bool> v249, func findrunnable
runtime/proc.go:1963: Inner loop invariant, header b58, val v249 = CMPQconst <flags> [2] v227, func findrunnable
runtime/proc.go:2612: Inner loop invariant, header b29, val v96 = TESTQ <flags> v47 v47, func exitsyscall
runtime/proc.go:3035: Inner loop invariant, header b2, val v29 = ADDQconst <**g> [3536] v5, func gfpurge
runtime/proc.go:3802: Inner loop invariant, header b5, val v243 = SARQconst <int64> [1] v295, func sysmon
runtime/proc.go:3802: Inner loop invariant, header b5, val v381 = SARQconst <int64> [63] v341, func sysmon
runtime/proc.go:3802: Inner loop invariant, header b5, val v256 = SHRQconst <int64> [63] v381, func sysmon
runtime/proc.go:3802: Inner loop invariant, header b5, val v295 = ADDQ <int64> v341 v256, func sysmon
runtime/runtime1.go:436: Inner loop invariant, header b2, val v18 = MOVLQSX <int64> v9, func timediv
runtime/select.go:404: Inner loop invariant, header b148, val v1135 = TESTQ <flags> v2042 v2042, func selectgoImpl
runtime/sema.go:132: Inner loop invariant, header b18, val v105 = LEAQ1 <*mutex> v38 v116, func semacquire1
runtime/sema.go:134: Inner loop invariant, header b18, val v110 = LEAQ1 <*uint32> [16] v38 v116, func semacquire1
runtime/sigqueue.go:66: Inner loop invariant, header b12, val v64 = LEAQ4 <*uint32> v39 v63, func sigsend
runtime/stack.go:199: Inner loop invariant, header b14, val v174 = SHLQ <uintptr> v97 v6, func stackpoolalloc
runtime/stack.go:199: Inner loop invariant, header b14, val v154 = CMPBconst <flags> [64] v6, func stackpoolalloc
runtime/stack.go:199: Inner loop invariant, header b14, val v173 = SBBQcarrymask <uintptr> v154, func stackpoolalloc
runtime/stack.go:199: Inner loop invariant, header b14, val v99 = ANDQ <uintptr> v174 v173, func stackpoolalloc
runtime/stack.go:200: Inner loop invariant, header b14, val v72 = ADDQconst <*uintptr> [24] v30, func stackpoolalloc
runtime/stack.go:272: Inner loop invariant, header b4, val v56 = ANDQ <uintptr> v86 v83, func stackcacherefill
runtime/stack.go:272: Inner loop invariant, header b4, val v86 = SHLQ <uintptr> v54 v7, func stackcacherefill
runtime/stack.go:272: Inner loop invariant, header b4, val v82 = CMPBconst <flags> [64] v7, func stackcacherefill
runtime/stack.go:272: Inner loop invariant, header b4, val v83 = SBBQcarrymask <uintptr> v82, func stackcacherefill
runtime/stack.go:291: Inner loop invariant, header b8, val v94 = CMPBconst <flags> [64] v7, func stackcacherelease
runtime/stack.go:291: Inner loop invariant, header b8, val v101 = SBBQcarrymask <uintptr> v94, func stackcacherelease
runtime/stack.go:291: Inner loop invariant, header b8, val v78 = ANDQ <uintptr> v103 v101, func stackcacherelease
runtime/stack.go:291: Inner loop invariant, header b8, val v103 = SHLQ <uintptr> v77 v7, func stackcacherelease
runtime/stack.go:592: Inner loop invariant, header b33, val v188 = TESTQ <flags> v11 v11, func adjustpointers
runtime/traceback.go:547: Inner loop invariant, header b4, val v128 = TESTB <flags> v11 v11, func tracebackCgoContext
runtime/traceback.go:556: Inner loop invariant, header b4, val v84 = TESTQ <flags> v10 v10, func tracebackCgoContext
runtime/traceback.go:749: Inner loop invariant, header b11, val v178 = CMPLconst <flags> [2] v52, func tracebackothers
runtime/type.go:278: Inner loop invariant, header b20, val v188 = MOVLQSX <uintptr> v8, func (*_type).textOff
runtime/panic.go:204: Inner loop invariant, header b2, val v24 = LEAQ8 <*[]*_defer> [56] v6 v152, func newdefer.func1
runtime/panic.go:204: Inner loop invariant, header b2, val v57 = CMPQconst <flags> [5] v9, func newdefer.func1
runtime/panic.go:204: Inner loop invariant, header b2, val v152 = LEAQ2 <int> v9 v9, func newdefer.func1
runtime/panic.go:204: Inner loop invariant, header b2, val v49 = LEAQ8 <**_defer> [152] v10 v9, func newdefer.func1
runtime/panic.go:256: Inner loop invariant, header b2, val v85 = CMPQconst <flags> [5] v9, func freedefer.func1
runtime/panic.go:256: Inner loop invariant, header b2, val v159 = LEAQ2 <int> v9 v9, func freedefer.func1
errors
internal/race
sync/atomic
unicode
unicode/utf8
math
sync
container/list
container/ring
# sync
sync/mutex.go:135: Inner loop invariant, header b9, val v121 = ADDQconst <*uint32> [4] v5, func (*Mutex).Lock
sync/pool.go:157: Inner loop invariant, header b2, val v22 = TESTQ <flags> v12 v12, func (*Pool).getSlow
sync/rwmutex.go:121: Inner loop invariant, header b10, val v38 = MOVLQSX <int> v28, func (*RWMutex).Unlock
sync/rwmutex.go:122: Inner loop invariant, header b10, val v43 = ADDQconst <*uint32> [12] v5, func (*RWMutex).Unlock
sync/waitgroup.go:94: Inner loop invariant, header b31, val v131 = ADDQconst <*uint32> [12] v6, func (*WaitGroup).Add
io
syscall
# io
io/pipe.go:41: Inner loop invariant, header b7, val v80 = ADDQconst <*[]byte> [24] v8, func (*pipe).read
io/pipe.go:47: Inner loop invariant, header b7, val v105 = ADDQconst <*sync.Cond> [48] v8, func (*pipe).read
io/pipe.go:90: Inner loop invariant, header b13, val v139 = ADDQconst <*sync.Cond> [104] v8, func (*pipe).write
hash
hash/adler32
hash/crc32
# hash/crc32
hash/crc32/crc32_amd64.go:71: Inner loop invariant, header b8, val v42 = CMPLconst <flags> [32] v107, func archInitCastagnoli
hash/crc32/crc32_amd64.go:71: Inner loop invariant, header b8, val v45 = SBBLcarrymask <uint32> v42, func archInitCastagnoli
hash/crc32/crc32_amd64.go:71: Inner loop invariant, header b8, val v107 = SHLQconst <int> [3] v36, func archInitCastagnoli
hash/crc32/crc32_amd64.go:72: Inner loop invariant, header b8, val v120 = SHLQconst <int> [10] v36, func archInitCastagnoli
crypto/subtle
crypto/cipher
bytes
strings
strconv
# bytes
bytes/bytes.go:99: Inner loop invariant, header b7, val v22 = CMPQconst <flags> [1] v48, func LastIndex
bytes/bytes.go:692: Inner loop invariant, header b15, val v219 = TESTQ <flags> v328 v328, func Replace
bufio
# strings
strings/replace.go:193: Inner loop invariant, header b2, val v137 = TESTB <flags> v12 v12, func (*genericReplacer).lookup
strings/search.go:93: Inner loop invariant, header b2, val v23 = ADDQconst <int> [-1] v37, func longestCommonSuffix
strings/search.go:93: Inner loop invariant, header b2, val v36 = ADDQconst <int> [-1] v34, func longestCommonSuffix
strings/strings.go:24: Inner loop invariant, header b5, val v36 = ADDQconst <int> [-1] v25, func explode
strings/strings.go:138: Inner loop invariant, header b42, val v134 = NEGQ <int> v182, func LastIndex
strings/strings.go:138: Inner loop invariant, header b42, val v191 = SARQconst <int> [63] v134, func LastIndex
strings/strings.go:708: Inner loop invariant, header b12, val v10 = TESTQ <flags> v289 v289, func Replace
strings/strings_amd64.go:58: Inner loop invariant, header b41, val v69 = NEGQ <int> v339, func Index
strings/strings_amd64.go:58: Inner loop invariant, header b41, val v170 = SARQconst <int> [63] v69, func Index
path
text/tabwriter
# bufio
bufio/bufio.go:176: Inner loop invariant, header b10, val v117 = ADDQconst <**uint8> [64] v8, func (*Reader).Discard
bufio/bufio.go:236: Inner loop invariant, header b2, val v29 = ADDQconst <**uint8> [64] v7, func (*Reader).ReadByte
crypto/internal/cipherhw
math/rand
# text/tabwriter
text/tabwriter/tabwriter.go:215: Inner loop invariant, header b6, val v50 = ADDQconst <*bytes.Buffer> [56] v5, func (*Writer).dump
text/tabwriter/tabwriter.go:355: Inner loop invariant, header b11, val v169 = SHLQconst <int> [3] v208, func (*Writer).format
text/tabwriter/tabwriter.go:355: Inner loop invariant, header b11, val v208 = LEAQ2 <int> v186 v186, func (*Writer).format
crypto/hmac
internal/nettrace
internal/singleflight
vendor/golang_org/x/crypto/poly1305
# strconv
strconv/decimal.go:116: Inner loop invariant, header b2, val v67 = CMPQconst <flags> [64] v7, func rightShift
strconv/decimal.go:116: Inner loop invariant, header b2, val v26 = SBBQcarrymask <uint> v67, func rightShift
strconv/decimal.go:281: Inner loop invariant, header b12, val v196 = CMPQconst <flags> [64] v7, func leftShift
strconv/decimal.go:281: Inner loop invariant, header b12, val v142 = SBBQcarrymask <uint> v196, func leftShift
strconv/extfloat.go:446: Inner loop invariant, header b38, val v167 = SHLQ <uint64> v73 v60, func (*extFloat).FixedDecimal
strconv/extfloat.go:446: Inner loop invariant, header b38, val v205 = ANDQ <uint64> v167 v217, func (*extFloat).FixedDecimal
strconv/extfloat.go:650: Inner loop invariant, header b4, val v113 = SHRQconst <uint64> [1] v15, func adjustLastDigit
strconv/itoa.go:111: Inner loop invariant, header b34, val v189 = CMPQconst <flags> [64] v117, func formatBits
strconv/itoa.go:111: Inner loop invariant, header b34, val v214 = SBBQcarrymask <uint64> v189, func formatBits
strconv/itoa.go:122: Inner loop invariant, header b46, val v246 = TESTQ <flags> v13 v13, func formatBits
strconv/quote.go:411: Inner loop invariant, header b59, val v264 = CMPBconst <flags> [39] v29, func Unquote
vendor/golang_org/x/crypto/curve25519
reflect
# vendor/golang_org/x/crypto/curve25519
vendor/golang_org/x/crypto/curve25519/mont25519_amd64.go:48: Inner loop invariant, header b9, val v158 = CMPQconst <flags> [32] v86, func mladder
cmd/internal/src
# syscall
syscall/route_bsd.go:89: Inner loop invariant, header b10, val v105 = LEAQ1 <int> [-4] v8 v31, func parseLinkLayerAddr
crypto
time
crypto/aes
crypto/sha512
crypto/md5
# crypto/aes
crypto/aes/block.go:151: Inner loop invariant, header b16, val v405 = TESTQ <flags> v13 v13, func expandKeyGo
crypto/aes/block.go:170: Inner loop invariant, header b52, val v371 = TESTQ <flags> v254 v254, func expandKeyGo
crypto/aes/block.go:170: Inner loop invariant, header b52, val v278 = ADDQconst <int> [4] v254, func expandKeyGo
crypto/aes/block.go:170: Inner loop invariant, header b52, val v2 = CMPQ <flags> v278 v344, func expandKeyGo
crypto/rc4
crypto/sha1
# crypto/rc4
crypto/rc4/rc4.go:39: Inner loop invariant, header b11, val v53 = TESTQ <flags> v115 v115, func NewCipher
crypto/sha256
# crypto/sha1
crypto/sha1/sha1.go:183: Inner loop invariant, header b53, val v323 = NOTL <byte> v50, func (*digest).constSum
encoding/base64
encoding
encoding/ascii85
# encoding/base64
encoding/base64/base64.go:196: Inner loop invariant, header b29, val v208 = ADDQconst <*[1024]byte> [56] v8, func (*encoder).Write
encoding/base64/base64.go:394: Inner loop invariant, header b12, val v620 = HMULQ <int> v580 v654, func (*decoder).Read
encoding/base64/base64.go:394: Inner loop invariant, header b12, val v573 = SARQconst <int> [63] v654, func (*decoder).Read
encoding/base64/base64.go:394: Inner loop invariant, header b12, val v626 = ADDQ <int> v654 v620, func (*decoder).Read
encoding/base64/base64.go:394: Inner loop invariant, header b12, val v111 = SUBQ <int> v627 v573, func (*decoder).Read
encoding/base64/base64.go:394: Inner loop invariant, header b12, val v627 = SARQconst <int> [1] v626, func (*decoder).Read
encoding/base64/base64.go:394: Inner loop invariant, header b12, val v107 = SHLQconst <int> [2] v111, func (*decoder).Read
encoding/base64/base64.go:395: Inner loop invariant, header b12, val v174 = CMPQconst <flags> [4] v107, func (*decoder).Read
encoding/base64/base64.go:401: Inner loop invariant, header b12, val v161 = ADDQconst <**uint8> [24] v8, func (*decoder).Read
encoding/base64/base64.go:401: Inner loop invariant, header b12, val v123 = ADDQconst <*[1024]byte> [57] v8, func (*decoder).Read
encoding/base32
# encoding/ascii85
encoding/ascii85/ascii85.go:135: Inner loop invariant, header b29, val v206 = ADDQconst <*[1024]byte> [48] v8, func (*encoder).Write
encoding/ascii85/ascii85.go:235: Inner loop invariant, header b49, val v204 = ADDQconst <int> [-1] v342, func Decode
unicode/utf16
# encoding/base32
encoding/base32/base32.go:182: Inner loop invariant, header b29, val v208 = ADDQconst <*[1024]byte> [56] v8, func (*encoder).Write
encoding/base32/base32.go:257: Inner loop invariant, header b29, val v536 = ADDQconst <int> [-7] v26, func (*Encoding).decode
encoding/base32/base32.go:257: Inner loop invariant, header b29, val v126 = NEGQ <int> v536, func (*Encoding).decode
vendor/golang_org/x/text/transform
hash/crc64
hash/fnv
html
# vendor/golang_org/x/text/transform
vendor/golang_org/x/text/transform/transform.go:166: Inner loop invariant, header b3, val v328 = ADDQconst <**uint8> [40] v8, func (*Reader).Read
vendor/golang_org/x/text/transform/transform.go:199: Inner loop invariant, header b3, val v468 = ADDQconst <**uint8> [40] v8, func (*Reader).Read
vendor/golang_org/x/text/transform/transform.go:407: Inner loop invariant, header b6, val v520 = TESTB <flags> v14 v14, func (*chain).Transform
image/color
image
# html
html/escape.go:86: Inner loop invariant, header b28, val v455 = TESTB <flags> v798 v798, func unescapeEntity
image/color/palette
internal/syscall/windows
internal/syscall/windows/registry
internal/syscall/windows/sysdll
runtime/trace
math/bits
math/cmplx
# time
time/format.go:521: Inner loop invariant, header b2, val v136 = MULQconst <int> [60] v135, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v1197 = SARQconst <int> [10] v1195, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v2541 = ADDQ <int> v133 v2447, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v131 = SUBQ <int> v1197 v1189, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v133 = SUBQ <int> v128 v132, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v2447 = HMULQ <int> v2298 v133, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v135 = SUBQ <int> v2662 v2119, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v137 = SUBQ <int> v133 v136, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v1189 = SARQconst <int> [63] v128, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v128 = SUBQ <uint64> v22 v1418, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v2662 = SARQconst <int> [5] v2541, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v2461 = HMULQU <uint64> v2352 v22, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v1248 = SHRQconst <uint64> [16] v2461, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v1195 = HMULQ <int> v1236 v128, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v132 = MULQconst <int> [3600] v131, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v2119 = SARQconst <int> [63] v133, func Time.AppendFormat
time/format.go:521: Inner loop invariant, header b2, val v1418 = MULQconst <uint64> [86400] v1248, func Time.AppendFormat
time/zoneinfo.go:309: Inner loop invariant, header b5, val v19 = ADDQconst <int> [-1] v42, func containsDotDot
time/zoneinfo_read.go:210: Inner loop invariant, header b216, val v1479 = ADDQconst <**zone> [80] v1348, func loadZoneData
internal/poll
runtime/race
cmd/compile/internal/test
cmd/vet/internal/whitelist
# internal/poll
internal/poll/fd_mutex.go:87: Inner loop invariant, header b13, val v58 = ADDQconst <*uint32> [8] v6, func (*fdMutex).increfAndClose
internal/poll/fd_mutex.go:91: Inner loop invariant, header b17, val v72 = ADDQconst <*uint32> [12] v6, func (*fdMutex).increfAndClose
internal/poll/fd_mutex.go:180: Inner loop invariant, header b6, val v49 = NOTQ <uint64> v100, func (*fdMutex).rwunlock
internal/poll/fd_unix.go:373: Inner loop invariant, header b7, val v85 = ADDQconst <*pollDesc> [24] v8, func (*FD).ReadDirent
os
image/internal/imageutil
image/draw
image/jpeg
# image/draw
image/draw/draw.go:204: Inner loop invariant, header b285, val v1148 = TESTQ <flags> v1299 v1299, func DrawMask
image/draw/draw.go:517: Inner loop invariant, header b41, val v942 = TESTQ <flags> v179 v179, func drawRGBA
image/draw/draw.go:521: Inner loop invariant, header b41, val v29 = TESTQ <flags> v17 v17, func drawRGBA
# os
os/file_unix.go:147: Inner loop invariant, header b13, val v75 = ORQconst <int> [16777216] v10, func OpenFile
os/file_unix.go:147: Inner loop invariant, header b13, val v43 = ANDLconst <FileMode> [511] v11, func OpenFile
os/file_unix.go:147: Inner loop invariant, header b13, val v222 = TESTLconst <flags> [8388608] v11, func OpenFile
os/file_unix.go:147: Inner loop invariant, header b13, val v55 = ORLconst <uint32> [2048] v43, func OpenFile
os/file_unix.go:147: Inner loop invariant, header b13, val v211 = TESTLconst <flags> [4194304] v11, func OpenFile
os/file_unix.go:147: Inner loop invariant, header b13, val v200 = TESTLconst <flags> [1048576] v11, func OpenFile
os/getwd.go:97: Inner loop invariant, header b94, val v163 = CMPQ <flags> v310 v75, func Getwd
vendor/golang_org/x/net/route
os/signal
# image/jpeg
image/jpeg/huffman.go:147: Inner loop invariant, header b57, val v43 = SBBLcarrymask <byte> v132, func (*decoder).processDHT
image/jpeg/huffman.go:147: Inner loop invariant, header b57, val v291 = ANDL <byte> v311 v43, func (*decoder).processDHT
image/jpeg/huffman.go:147: Inner loop invariant, header b57, val v311 = SHLL <byte> v57 v264, func (*decoder).processDHT
image/jpeg/huffman.go:148: Inner loop invariant, header b57, val v300 = LEAQ1 <*[256]uint16> [4] v98 v380, func (*decoder).processDHT
image/jpeg/huffman.go:210: Inner loop invariant, header b25, val v4 = ADDQconst <*uint32> [20] v8, func (*decoder).decodeHuffman
image/jpeg/reader.go:251: Inner loop invariant, header b10, val v96 = ADDQconst <*[4096]byte> [32] v7, func (*decoder).readFull
image/jpeg/reader.go:446: Inner loop invariant, header b29, val v107 = ANDLconst <int> [15] v23, func (*decoder).processDQT
image/jpeg/reader.go:446: Inner loop invariant, header b29, val v9 = CMPQconst <flags> [4] v107, func (*decoder).processDQT
image/jpeg/reader.go:446: Inner loop invariant, header b29, val v138 = SHLQconst <int> [8] v107, func (*decoder).processDQT
image/jpeg/reader.go:446: Inner loop invariant, header b29, val v112 = LEAQ1 <*block> [12144] v7 v138, func (*decoder).processDQT
image/jpeg/reader.go:457: Inner loop invariant, header b45, val v233 = CMPQconst <flags> [4] v185, func (*decoder).processDQT
image/jpeg/reader.go:457: Inner loop invariant, header b45, val v89 = SHLQconst <int> [8] v185, func (*decoder).processDQT
image/jpeg/reader.go:457: Inner loop invariant, header b45, val v189 = LEAQ1 <*block> [12144] v7 v89, func (*decoder).processDQT
image/jpeg/reader.go:457: Inner loop invariant, header b45, val v185 = ANDLconst <int> [15] v23, func (*decoder).processDQT
image/jpeg/reader.go:690: Inner loop invariant, header b18, val v135 = SUBQ <int> v109 v598, func (*decoder).applyBlack
image/jpeg/reader.go:729: Inner loop invariant, header b51, val v458 = MULQ <int> v531 v527, func (*decoder).applyBlack
image/jpeg/reader.go:758: Inner loop invariant, header b20, val v95 = TESTQ <flags> v26 v26, func (*decoder).convertToRGB
image/jpeg/scan.go:451: Inner loop invariant, header b26, val v137 = MULQ <int> v106 v105, func (*decoder).reconstructProgressiveImage
image/jpeg/writer.go:206: Inner loop invariant, header b2, val v27 = ADDQconst <*huffmanSpec> [16] v2, func init.2
image/jpeg/writer.go:396: Inner loop invariant, header b6, val v47 = ADDQ <int> v166 v31, func toYCbCr
image/jpeg/writer.go:396: Inner loop invariant, header b6, val v70 = CMPQ <flags> v47 v29, func toYCbCr
image/jpeg/writer.go:413: Inner loop invariant, header b8, val v48 = ADDQ <int> v78 v31, func grayToY
image/jpeg/writer.go:413: Inner loop invariant, header b8, val v114 = CMPQ <flags> v48 v25, func grayToY
image/jpeg/writer.go:413: Inner loop invariant, header b8, val v70 = ADDQconst <*image.Rectangle> [32] v7, func grayToY
image/jpeg/writer.go:413: Inner loop invariant, header b8, val v52 = ADDQconst <*int> [40] v7, func grayToY
image/jpeg/writer.go:459: Inner loop invariant, header b10, val v64 = ADDQconst <*image.Rectangle> [96] v9, func yCbCrToYCbCr
image/jpeg/writer.go:459: Inner loop invariant, header b10, val v179 = ADDQconst <*int> [104] v9, func yCbCrToYCbCr
image/jpeg/writer.go:475: Inner loop invariant, header b10, val v28 = SHLQconst <int> [4] v22, func scale
image/jpeg/writer.go:476: Inner loop invariant, header b10, val v60 = SHLQconst <int> [8] v9, func scale
image/jpeg/writer.go:476: Inner loop invariant, header b10, val v39 = ADDQ <*block> v7 v60, func scale
image/jpeg/writer.go:544: Inner loop invariant, header b57, val v330 = TESTQ <flags> v150 v150, func (*encoder).writeSOS
image/jpeg/writer.go:606: Inner loop invariant, header b43, val v260 = SHLQconst <int> [6] v193, func Encode
image/jpeg/writer.go:606: Inner loop invariant, header b43, val v207 = ADDQ <*[64]byte> v202 v260, func Encode
image/jpeg/writer.go:613: Inner loop invariant, header b43, val v230 = LEAQ1 <*[64]byte> [56] v68 v260, func Encode
# os/signal
os/signal/signal.go:173: Inner loop invariant, header b6, val v94 = SARQconst <int> [63] v10, func process
os/signal/signal.go:173: Inner loop invariant, header b6, val v71 = SHRQconst <int> [59] v94, func process
os/signal/signal.go:173: Inner loop invariant, header b6, val v82 = ANDQconst <int> [31] v10, func process
os/signal/signal.go:173: Inner loop invariant, header b6, val v133 = ADDQ <int> v10 v71, func process
os/signal/signal.go:173: Inner loop invariant, header b6, val v72 = SARQconst <int> [5] v133, func process
os/signal/signal.go:173: Inner loop invariant, header b6, val v110 = CMPQconst <flags> [3] v72, func process
os/signal/signal.go:45: Inner loop invariant, header b2, val v196 = SARQconst <int> [63] v5, func cancel.func1
os/signal/signal.go:45: Inner loop invariant, header b2, val v89 = SHRQconst <int> [59] v196, func cancel.func1
os/signal/signal.go:45: Inner loop invariant, header b2, val v59 = ANDQconst <int> [31] v5, func cancel.func1
os/signal/signal.go:45: Inner loop invariant, header b2, val v139 = ADDQ <int> v5 v89, func cancel.func1
os/signal/signal.go:45: Inner loop invariant, header b2, val v49 = SARQconst <int> [5] v139, func cancel.func1
os/signal/signal.go:45: Inner loop invariant, header b2, val v87 = CMPQconst <flags> [3] v49, func cancel.func1
os/signal/signal.go:46: Inner loop invariant, header b2, val v39 = CMPQconst <flags> [65] v5, func cancel.func1
os/signal/signal.go:47: Inner loop invariant, header b2, val v161 = SHLL <uint32> v62 v59, func cancel.func1
os/signal/signal.go:47: Inner loop invariant, header b2, val v104 = NOTL <uint32> v161, func cancel.func1
# reflect
reflect/deepequal.go:68: Inner loop invariant, header b69, val v253 = ADDQconst <int> [1] v12, func deepValueEqual
reflect/deepequal.go:84: Inner loop invariant, header b87, val v353 = ADDQconst <int> [1] v12, func deepValueEqual
reflect/deepequal.go:101: Inner loop invariant, header b108, val v509 = ADDQconst <int> [1] v12, func deepValueEqual
reflect/deepequal.go:119: Inner loop invariant, header b126, val v644 = ADDQconst <int> [1] v12, func deepValueEqual
reflect/type.go:1264: Inner loop invariant, header b6, val v91 = ADDQconst <*StructField> [24] v2, func (*structType).FieldByIndex
reflect/type.go:1369: Inner loop invariant, header b19, val v18 = SHLQconst <uintptr> [3] v863, func (*structType).FieldByNameFunc
reflect/type.go:1370: Inner loop invariant, header b19, val v561 = ADDQconst <int> [1] v863, func (*structType).FieldByNameFunc
reflect/type.go:1608: Inner loop invariant, header b89, val v111 = TESTB <flags> v10 v10, func haveIdenticalUnderlyingType
reflect/type.go:3179: Inner loop invariant, header b25, val v234 = SHRQconst <uintptr> [3] v8, func addTypeBits
reflect/type.go:3180: Inner loop invariant, header b25, val v73 = ADDQconst <*[]byte> [8] v7, func addTypeBits
reflect/type.go:3186: Inner loop invariant, header b46, val v611 = SHRQconst <uintptr> [3] v8, func addTypeBits
reflect/type.go:3187: Inner loop invariant, header b46, val v268 = ADDQconst <*[]byte> [8] v7, func addTypeBits
reflect/value.go:1810: Inner loop invariant, header b10, val v25 = CMPQconst <flags> [1024] v20, func grow
fmt
sort
encoding/binary
# sort
sort/sort.go:458: Inner loop invariant, header b11, val v50 = ADDQconst <int> [-1] v17, func symMerge
sort/zfuncversion.go:199: Inner loop invariant, header b11, val v46 = ADDQconst <int> [-1] v17, func symMerge_func
path/filepath
regexp/syntax
# encoding/binary
encoding/binary/binary.go:402: Inner loop invariant, header b26, val v85 = ADDQconst <*reflect.StructField> [24] v2, func sizeof
encoding/binary/binary.go:520: Inner loop invariant, header b82, val v584 = ADDQconst <*reflect.StructField> [24] v2, func (*decoder).value
encoding/binary/binary.go:585: Inner loop invariant, header b46, val v147 = ADDQconst <*reflect.StructField> [24] v2, func (*encoder).value
cmd/internal/sys
compress/bzip2
io/ioutil
container/heap
# compress/bzip2
compress/bzip2/bzip2.go:258: Inner loop invariant, header b12, val v119 = SHLQconst <uint> [4] v91, func (*reader).readBlock
compress/bzip2/bzip2.go:402: Inner loop invariant, header b127, val v363 = TESTQ <flags> v946 v946, func (*reader).readBlock
crypto/des
encoding/pem
# crypto/des
crypto/des/block.go:84: Inner loop invariant, header b2, val v31 = ADDQconst <int> [-1] v36, func permuteBlock
crypto/des/block.go:93: Inner loop invariant, header b10, val v105 = SHLQconst <int> [4] v10, func init.1
crypto/des/block.go:93: Inner loop invariant, header b10, val v24 = ADDQ <*[16]uint8> v21 v105, func init.1
crypto/des/block.go:93: Inner loop invariant, header b10, val v21 = ADDQ <*[4][16]uint8> v16 v108, func init.1
crypto/des/block.go:93: Inner loop invariant, header b10, val v108 = SHLQconst <int> [6] v6, func init.1
crypto/des/block.go:93: Inner loop invariant, header b10, val v104 = CMPQconst <flags> [64] v36, func init.1
crypto/des/block.go:93: Inner loop invariant, header b10, val v103 = SBBQcarrymask <uint64> v104, func init.1
crypto/des/block.go:93: Inner loop invariant, header b10, val v36 = SHLQconst <uint> [2] v35, func init.1
crypto/des/block.go:93: Inner loop invariant, header b10, val v113 = ADDQconst <uint> [-7] v6, func init.1
crypto/des/block.go:93: Inner loop invariant, header b10, val v35 = NEGQ <uint> v113, func init.1
crypto/des/block.go:98: Inner loop invariant, header b10, val v57 = ANDQconst <int> [2] v10, func init.1
crypto/des/block.go:98: Inner loop invariant, header b10, val v79 = SHLQconst <int> [4] v57, func init.1
crypto/des/block.go:98: Inner loop invariant, header b10, val v61 = ORQ <int> v60 v79, func init.1
crypto/des/block.go:98: Inner loop invariant, header b10, val v60 = ANDQconst <int> [1] v10, func init.1
crypto/des/block.go:105: Inner loop invariant, header b10, val v78 = ADDQ <*[64]uint32> v73 v46, func init.1
crypto/des/block.go:105: Inner loop invariant, header b10, val v46 = SHLQconst <int> [8] v6, func init.1
vendor/golang_org/x/crypto/chacha20poly1305/internal/chacha20
runtime/debug
vendor/golang_org/x/crypto/chacha20poly1305
# runtime/debug
runtime/debug/garbage.go:77: Inner loop invariant, header b58, val v92 = CMPQconst <flags> [1] v295, func ReadGCStats
# fmt
fmt/format.go:379: Inner loop invariant, header b29, val v11 = CMPQconst <flags> [16] v481, func (*fmt).fmt_sbx
fmt/print.go:97: Inner loop invariant, header b6, val v64 = ADDQconst <int> [4] v110, func (*buffer).WriteRune
fmt/print.go:468: Inner loop invariant, header b63, val v473 = ADDQconst <*fmt> [64] v8, func (*pp).fmtBytes
fmt/print.go:748: Inner loop invariant, header b148, val v887 = ADDQconst <int> [1] v11, func (*pp).printValue
fmt/print.go:771: Inner loop invariant, header b190, val v2570 = ADDQconst <*reflect.StructField> [24] v2, func (*pp).printValue
fmt/print.go:776: Inner loop invariant, header b190, val v1488 = ADDQconst <int> [1] v11, func (*pp).printValue
fmt/print.go:826: Inner loop invariant, header b315, val v2261 = ADDQconst <int> [1] v11, func (*pp).printValue
fmt/print.go:835: Inner loop invariant, header b333, val v2427 = ADDQconst <int> [1] v11, func (*pp).printValue
fmt/scan.go:356: Inner loop invariant, header b46, val v117 = ADDQconst <*[4]byte> [16] v8, func (*readRune).ReadRune
fmt/scan.go:468: Inner loop invariant, header b5, val v47 = ADDQconst <*buffer> [16] v8, func (*ss).token
fmt/scan.go:837: Inner loop invariant, header b12, val v33 = ADDQconst <*buffer> [16] v6, func (*ss).quotedString
fmt/scan.go:909: Inner loop invariant, header b3, val v24 = ADDQconst <*buffer> [16] v6, func (*ss).hexString
cmd/internal/dwarf
flag
log
debug/dwarf
compress/flate
cmd/internal/obj
# regexp/syntax
regexp/syntax/parse.go:562: Inner loop invariant, header b242, val v1255 = ADDQconst <**Regexp> [32] v8, func (*parser).factor
regexp/syntax/parse.go:1676: Inner loop invariant, header b2, val v52 = ADDLconst <rune> [1] v10, func appendRange
debug/gosym
# debug/gosym
debug/gosym/symtab.go:332: Inner loop invariant, header b41, val v323 = LEAQ1 <*string> [16] v525 v415, func NewTable.func2
debug/plan9obj
# debug/plan9obj
debug/plan9obj/file.go:285: Inner loop invariant, header b16, val v208 = LEAQ1 <*string> [16] v251 v119, func newTable.func2
cmd/vendor/golang.org/x/arch/arm/armasm
# compress/flate
compress/flate/huffman_bit_writer.go:285: Inner loop invariant, header b73, val v365 = MOVBQZX <int> v151, func (*huffmanBitWriter).generateCodegen
compress/flate/huffman_bit_writer.go:285: Inner loop invariant, header b73, val v186 = CMPQconst <flags> [19] v365, func (*huffmanBitWriter).generateCodegen
compress/flate/huffman_code.go:163: Inner loop invariant, header b13, val v225 = CMPQconst <flags> [1] v26, func (*huffmanEncoder).bitCounts
compress/flate/huffman_code.go:163: Inner loop invariant, header b13, val v427 = ADDQconst <*int32> [12] v495, func (*huffmanEncoder).bitCounts
compress/flate/huffman_code.go:164: Inner loop invariant, header b13, val v224 = CMPQconst <flags> [2] v26, func (*huffmanEncoder).bitCounts
compress/flate/huffman_code.go:262: Inner loop invariant, header b12, val v42 = SBBLcarrymask <uint16> v225, func (*huffmanEncoder).assignEncodingAndSize
compress/flate/huffman_code.go:262: Inner loop invariant, header b12, val v118 = ADDLconst <byte> [-16] v16, func (*huffmanEncoder).assignEncodingAndSize
compress/flate/huffman_code.go:262: Inner loop invariant, header b12, val v76 = NEGL <byte> v118, func (*huffmanEncoder).assignEncodingAndSize
compress/flate/huffman_code.go:262: Inner loop invariant, header b12, val v225 = CMPBconst <flags> [32] v76, func (*huffmanEncoder).assignEncodingAndSize
compress/flate/inflate.go:200: Inner loop invariant, header b67, val v381 = SHLQ <int> v56 v279, func (*huffmanDecoder).init
compress/flate/inflate.go:200: Inner loop invariant, header b67, val v405 = CMPQconst <flags> [64] v279, func (*huffmanDecoder).init
compress/flate/inflate.go:200: Inner loop invariant, header b67, val v380 = SBBQcarrymask <int> v405, func (*huffmanDecoder).init
compress/flate/inflate.go:200: Inner loop invariant, header b67, val v373 = ANDQ <int> v381 v380, func (*huffmanDecoder).init
compress/flate/inflate.go:221: Inner loop invariant, header b87, val v464 = ANDQ <int> v615 v461, func (*huffmanDecoder).init
compress/flate/inflate.go:221: Inner loop invariant, header b87, val v461 = SHLQ <int> v56 v462, func (*huffmanDecoder).init
compress/flate/inflate.go:221: Inner loop invariant, header b87, val v623 = CMPQconst <flags> [64] v462, func (*huffmanDecoder).init
compress/flate/inflate.go:221: Inner loop invariant, header b87, val v615 = SBBQcarrymask <int> v623, func (*huffmanDecoder).init
compress/flate/inflate.go:221: Inner loop invariant, header b87, val v462 = ADDQconst <int> [-9] v279, func (*huffmanDecoder).init
compress/flate/inflate.go:302: Inner loop invariant, header b2, val v25 = ADDQconst <**uint8> [4320] v5, func (*decompressor).nextBlock
compress/flate/inflate.go:335: Inner loop invariant, header b3, val v15 = ADDQconst <*[]byte> [4328] v8, func (*decompressor).Read
compress/zlib
cmd/vendor/golang.org/x/arch/ppc64/ppc64asm
# debug/dwarf
debug/dwarf/buf.go:82: Inner loop invariant, header b2, val v12 = ADDQconst <*[]byte> [64] v6, func (*buf).string
debug/dwarf/buf.go:121: Inner loop invariant, header b2, val v14 = ADDQconst <*[]byte> [64] v7, func (*buf).varint
debug/dwarf/line.go:255: Inner loop invariant, header b138, val v1465 = ADDQconst <*[]string> [208] v6, func (*LineReader).readHeader
debug/dwarf/line.go:571: Inner loop invariant, header b14, val v167 = ADDQconst <*LineEntry> [280] v8, func (*LineReader).SeekPC
debug/dwarf/line.go:571: Inner loop invariant, header b14, val v91 = ADDQconst <*LineEntry> [272] v8, func (*LineReader).SeekPC
debug/elf
# cmd/internal/obj
cmd/internal/obj/objfile.go:167: Inner loop invariant, header b4, val v165 = ADDQconst <*int> [80] v40, func (*objWriter).addLengths
cmd/internal/obj/objfile.go:348: Inner loop invariant, header b46, val v521 = ADDQconst <int> [16] v468, func (*objWriter).writeSymDebug
cmd/internal/obj/pass.go:171: Inner loop invariant, header b18, val v145 = MOVLQSX <int64> v136, func linkpatch
cmd/internal/obj/plist.go:32: Inner loop invariant, header b127, val v802 = TESTB <flags> v7 v7, func flushplist
cmd/internal/goobj
debug/macho
# cmd/internal/goobj
cmd/internal/goobj/read.go:435: Inner loop invariant, header b22, val v110 = ADDQconst <*[256]byte> [72] v6, func (*objReader).skip
cmd/internal/goobj/read.go:498: Inner loop invariant, header b2, val v20 = ADDQconst <*[256]byte> [72] v6, func (*objReader).parseArchive
cmd/internal/goobj/read.go:522: Inner loop invariant, header b2, val v80 = ADDQconst <*byte> [130] v6, func (*objReader).parseArchive
cmd/internal/goobj/read.go:526: Inner loop invariant, header b2, val v129 = LEAQ1 <*byte> [72] v6 v116, func (*objReader).parseArchive
debug/pe
cmd/vendor/golang.org/x/arch/x86/x86asm
# debug/macho
debug/macho/file.go:352: Inner loop invariant, header b147, val v1580 = ADDQconst <*[]*Section> [72] v15, func NewFile
debug/macho/file.go:390: Inner loop invariant, header b171, val v1988 = ADDQconst <*[]*Section> [72] v15, func NewFile
regexp
# debug/elf
debug/elf/elf.go:2212: Inner loop invariant, header b2, val v94 = TESTB <flags> v10 v10, func flagName
archive/tar
archive/zip
# archive/tar
archive/tar/reader.go:131: Inner loop invariant, header b4, val v104 = ADDQconst <**uint8> [32] v7, func (*Reader).next
archive/tar/reader.go:324: Inner loop invariant, header b2, val v694 = ADDQconst <*map[string]string> [192] v7, func mergePAX
archive/tar/reader.go:542: Inner loop invariant, header b33, val v140 = SUBQ <int> v433 v416, func (*Reader).readOldGNUSparseMap
archive/tar/reader.go:542: Inner loop invariant, header b33, val v432 = HMULQ <int> v406 v366, func (*Reader).readOldGNUSparseMap
archive/tar/reader.go:542: Inner loop invariant, header b33, val v416 = SARQconst <int> [63] v366, func (*Reader).readOldGNUSparseMap
archive/tar/reader.go:542: Inner loop invariant, header b33, val v428 = ADDQ <int> v432 v366, func (*Reader).readOldGNUSparseMap
archive/tar/reader.go:542: Inner loop invariant, header b33, val v433 = SARQconst <int> [4] v428, func (*Reader).readOldGNUSparseMap
archive/tar/reader.go:773: Inner loop invariant, header b2, val v15 = ADDQconst <*[]sparseEntry> [16] v8, func (*sparseFileReader).Read
archive/tar/writer.go:62: Inner loop invariant, header b6, val v121 = ADDQconst <**uint8> [24] v6, func (*Writer).Flush
compress/gzip
# regexp
regexp/exec.go:187: Inner loop invariant, header b2, val v32 = ADDQconst <*[]*thread> [136] v6, func (*machine).clear
regexp/exec.go:225: Inner loop invariant, header b62, val v279 = ADDQconst <*[]*thread> [136] v11, func (*machine).step
regexp/exec.go:245: Inner loop invariant, header b2, val v415 = ADDQconst <*[]*thread> [136] v11, func (*machine).step
regexp/regexp.go:1140: Inner loop invariant, header b10, val v96 = ADDQconst <int> [-1] v10, func (*Regexp).Split
compress/lzw
# compress/gzip
compress/gzip/gunzip.go:148: Inner loop invariant, header b3, val v40 = ADDQconst <*[512]byte> [128] v7, func (*Reader).readString
context
# compress/lzw
compress/lzw/reader.go:118: Inner loop invariant, header b3, val v15 = ADDQconst <*[]byte> [20576] v8, func (*decoder).Read
math/big
encoding/hex
# encoding/hex
encoding/hex/hex.go:152: Inner loop invariant, header b2, val v68 = ADDQconst <*[14]byte> [34] v8, func (*dumper).Write
encoding/hex/hex.go:152: Inner loop invariant, header b2, val v78 = ADDQconst <*byte> [38] v8, func (*dumper).Write
encoding/hex/hex.go:160: Inner loop invariant, header b2, val v152 = ADDQconst <*[14]byte> [34] v8, func (*dumper).Write
encoding/hex/hex.go:179: Inner loop invariant, header b2, val v281 = ADDQconst <*[18]byte> [16] v8, func (*dumper).Write
encoding/hex/hex.go:213: Inner loop invariant, header b4, val v74 = ADDQconst <*[14]byte> [34] v6, func (*dumper).Close
go/token
os/exec
go/scanner
go/ast
# cmd/vendor/golang.org/x/arch/x86/x86asm
cmd/vendor/golang.org/x/arch/x86/x86asm/gnu.go:864: Inner loop invariant, header b2, val v29 = MOVBQZX <Prefix> v8, func countPrefix
cmd/vendor/golang.org/x/arch/x86/x86asm/intel.go:75: Inner loop invariant, header b131, val v507 = MOVBQZX <Prefix> v485, func IntelSyntax
cmd/internal/objfile
# cmd/internal/objfile
cmd/internal/objfile/disasm.go:124: Inner loop invariant, header b19, val v129 = TESTQ <flags> v11 v11, func (*Disasm).Print
cmd/internal/objfile/disasm.go:178: Inner loop invariant, header b16, val v171 = ADDQ <uint64> v258 v125, func (*Disasm).Decode
cmd/internal/objfile/disasm.go:184: Inner loop invariant, header b16, val v204 = SUBQ <uint64> v73 v306, func (*Disasm).Decode
cmd/internal/objfile/plan9obj.go:108: Inner loop invariant, header b4, val v61 = ADDQconst <*string> [16] v34, func findPlan9Symbol
cmd/addr2line
# os/exec
os/exec/exec.go:349: Inner loop invariant, header b21, val v258 = ADDQconst <*[]*os.File> [216] v6, func (*Cmd).Start
database/sql/driver
# go/ast
go/ast/commentmap.go:187: Inner loop invariant, header b14, val v315 = ADDQconst <*token.Position> [24] v2, func NewCommentMap
go/ast/filter.go:77: Inner loop invariant, header b4, val v37 = TESTB <flags> v10 v10, func filterFieldList
go/ast/filter.go:377: Inner loop invariant, header b39, val v268 = TESTQconst <flags> [1] v8, func MergePackageFiles
go/ast/import.go:33: Inner loop invariant, header b19, val v344 = ADDQconst <*token.Position> [24] v2, func SortImports
go/ast/import.go:47: Inner loop invariant, header b54, val v418 = ADDQconst <int> [1] v397, func SortImports
go/ast/import.go:112: Inner loop invariant, header b13, val v562 = TESTQ <flags> v797 v797, func sortSpecs
go/ast/import.go:147: Inner loop invariant, header b67, val v456 = ADDQconst <int> [-1] v695, func sortSpecs
go/ast/print.go:221: Inner loop invariant, header b91, val v354 = ADDQconst <*reflect.StructField> [24] v2, func (*printer).print
go/parser
go/printer
# math/big
math/big/arith.go:259: Inner loop invariant, header b6, val v26 = CMPQconst <flags> [64] v10, func shlVU_g
math/big/arith.go:259: Inner loop invariant, header b6, val v60 = SBBQcarrymask <Word> v26, func shlVU_g
math/big/arith.go:271: Inner loop invariant, header b6, val v32 = ADDQconst <int> [-1] v60, func shrVU_g
math/big/arith.go:274: Inner loop invariant, header b6, val v9 = CMPQconst <flags> [64] v10, func shrVU_g
math/big/arith.go:274: Inner loop invariant, header b6, val v40 = SBBQcarrymask <Word> v9, func shrVU_g
math/big/decimal.go:110: Inner loop invariant, header b2, val v212 = CMPQconst <flags> [64] v7, func shr
math/big/decimal.go:110: Inner loop invariant, header b2, val v183 = SBBQcarrymask <Word> v212, func shr
math/big/int.go:485: Inner loop invariant, header b59, val v1047 = CMPQ <flags> v290 v331, func (*Int).GCD
math/big/int.go:489: Inner loop invariant, header b59, val v1329 = CMPQ <flags> v319 v331, func (*Int).GCD
math/big/int.go:489: Inner loop invariant, header b59, val v484 = ADDQconst <*nat> [8] v319, func (*Int).GCD
math/big/int.go:491: Inner loop invariant, header b59, val v754 = CMPQ <flags> v307 v331, func (*Int).GCD
math/big/int.go:495: Inner loop invariant, header b59, val v946 = CMPQ <flags> v321 v331, func (*Int).GCD
math/big/int.go:650: Inner loop invariant, header b48, val v494 = CMPQ <flags> v94 v87, func Jacobi
math/big/int.go:651: Inner loop invariant, header b48, val v433 = CMPQ <flags> v87 v91, func Jacobi
math/big/nat.go:225: Inner loop invariant, header b15, val v213 = TESTQ <flags> v174 v174, func nat.montgomery
math/big/nat.go:227: Inner loop invariant, header b15, val v161 = CMPQ <flags> v174 v130, func nat.montgomery
math/big/nat.go:227: Inner loop invariant, header b15, val v134 = SARQconst <int> [63] v160, func nat.montgomery
math/big/nat.go:227: Inner loop invariant, header b15, val v135 = ANDQconst <int> [8] v134, func nat.montgomery
math/big/nat.go:227: Inner loop invariant, header b15, val v130 = ADDQconst <int> [-1] v174, func nat.montgomery
math/big/nat.go:227: Inner loop invariant, header b15, val v131 = ADDQconst <int> [-1] v177, func nat.montgomery
math/big/nat.go:227: Inner loop invariant, header b15, val v160 = NEGQ <int> v131, func nat.montgomery
math/big/nat.go:227: Inner loop invariant, header b15, val v136 = ADDQ <*Word> v233 v135, func nat.montgomery
math/big/nat.go:230: Inner loop invariant, header b15, val v166 = ADDQconst <int> [-1] v16, func nat.montgomery
math/big/nat.go:230: Inner loop invariant, header b15, val v138 = CMPQ <flags> v166 v174, func nat.montgomery
math/big/nat.go:1052: Inner loop invariant, header b34, val v344 = CMPQ <flags> v205 v204, func nat.expNNWindowed
math/big/nat.go:1149: Inner loop invariant, header b83, val v722 = CMPQ <flags> v457 v456, func nat.expNNMontgomery
math/big/natconv.go:404: Inner loop invariant, header b56, val v102 = TESTQ <flags> v12 v12, func nat.convertWords
math/big/natconv.go:448: Inner loop invariant, header b5, val v33 = SARQconst <int> [1] v9, func divisors
math/big/prime.go:304: Inner loop invariant, header b108, val v719 = ADDQconst <int> [-1] v242, func nat.probablyPrimeLucas
crypto/dsa
# crypto/dsa
crypto/dsa/dsa.go:104: Inner loop invariant, header b46, val v190 = SHLQconst <int> [2] v68, func GenerateParameters
crypto/dsa/dsa.go:109: Inner loop invariant, header b46, val v292 = CMPQ <flags> v210 v289, func GenerateParameters
crypto/dsa/dsa.go:109: Inner loop invariant, header b46, val v210 = ADDQconst <int> [-1] v289, func GenerateParameters
crypto/dsa/dsa.go:110: Inner loop invariant, header b46, val v179 = TESTQ <flags> v289 v289, func GenerateParameters
crypto/elliptic
encoding/asn1
# crypto/elliptic
crypto/elliptic/elliptic.go:289: Inner loop invariant, header b2, val v129 = TESTQ <flags> v94 v94, func GenerateKey
crypto/elliptic/elliptic.go:289: Inner loop invariant, header b2, val v99 = SHLQconst <int> [3] v85, func GenerateKey
crypto/elliptic/elliptic.go:289: Inner loop invariant, header b2, val v87 = SUBQ <int> v31 v99, func GenerateKey
crypto/elliptic/elliptic.go:289: Inner loop invariant, header b2, val v190 = ADDQ <int> v73 v31, func GenerateKey
crypto/elliptic/elliptic.go:289: Inner loop invariant, header b2, val v184 = SARQconst <int> [63] v31, func GenerateKey
crypto/elliptic/elliptic.go:289: Inner loop invariant, header b2, val v73 = SHRQconst <int> [61] v184, func GenerateKey
crypto/elliptic/elliptic.go:289: Inner loop invariant, header b2, val v85 = SARQconst <int> [3] v190, func GenerateKey
crypto/elliptic/elliptic.go:292: Inner loop invariant, header b2, val v39 = CMPQconst <flags> [1] v94, func GenerateKey
crypto/elliptic/p224.go:704: Inner loop invariant, header b2, val v75 = CMPQconst <flags> [4] v9, func get28BitsFromEnd
crypto/elliptic/p224.go:708: Inner loop invariant, header b2, val v89 = CMPQconst <flags> [32] v9, func get28BitsFromEnd
crypto/elliptic/p224.go:708: Inner loop invariant, header b2, val v91 = SBBLcarrymask <uint32> v89, func get28BitsFromEnd
crypto/elliptic/p256_amd64.go:535: Inner loop invariant, header b180, val v1508 = ADDQconst <*uint64> [32] v20, func (*p256Point).p256ScalarMult
crypto/rand
# go/parser
go/parser/interface.go:153: Inner loop invariant, header b8, val v71 = TESTQ <flags> v12 v12, func ParseDir
go/parser/parser.go:132: Inner loop invariant, header b2, val v138 = ADDQconst <*token.Position> [24] v2, func (*parser).declare
database/sql
# go/printer
go/printer/nodes.go:238: Inner loop invariant, header b32, val v218 = CMPQconst <flags> [1] v753, func (*printer).exprList
go/printer/nodes.go:463: Inner loop invariant, header b89, val v772 = MOVBQZX <int> v1274, func (*printer).fieldList
go/printer/nodes.go:463: Inner loop invariant, header b89, val v773 = ADDQ <*uint8> v210 v772, func (*printer).fieldList
go/printer/nodes.go:484: Inner loop invariant, header b102, val v948 = ADDQconst <**int> [248] v8, func (*printer).fieldList
go/printer/nodes.go:783: Inner loop invariant, header b290, val v1499 = CMPQconst <flags> [1] v11, func (*printer).expr1
go/printer/nodes.go:790: Inner loop invariant, header b290, val v1500 = ADDQconst <int> [1] v11, func (*printer).expr1
go/printer/nodes.go:1479: Inner loop invariant, header b22, val v279 = ADDQconst <**int> [248] v6, func (*printer).genDecl
go/printer/nodes.go:1488: Inner loop invariant, header b35, val v392 = ADDQconst <**int> [248] v6, func (*printer).genDecl
go/printer/printer.go:223: Inner loop invariant, header b21, val v280 = ADDQconst <*[]byte> [32] v6, func (*printer).atLineBegin
go/printer/printer.go:239: Inner loop invariant, header b4, val v32 = ADDQconst <*[]byte> [32] v7, func (*printer).writeByte
go/printer/printer.go:668: Inner loop invariant, header b49, val v198 = ADDQconst <*token.Position> [136] v6, func (*printer).writeComment
go/printer/printer.go:736: Inner loop invariant, header b12, val v148 = ADDQconst <*token.Position> [56] v2, func (*printer).intersperseComments
go/printer/printer.go:736: Inner loop invariant, header b12, val v261 = ADDQconst <*token.Position> [24] v2, func (*printer).intersperseComments
go/printer/printer.go:970: Inner loop invariant, header b2, val v230 = ADDQconst <*token.Position> [136] v6, func (*printer).print
go/printer/printer.go:993: Inner loop invariant, header b2, val v550 = ADDQconst <**int> [248] v6, func (*printer).print
cmd/cgo
# crypto/rand
crypto/rand/util.go:84: Inner loop invariant, header b59, val v338 = CMPQconst <flags> [6] v9, func Prime
crypto/rand/util.go:129: Inner loop invariant, header b14, val v168 = TESTQ <flags> v116 v116, func Int
crypto/rand/util.go:129: Inner loop invariant, header b14, val v163 = SHLQ <int> v24 v151, func Int
crypto/rand/util.go:129: Inner loop invariant, header b14, val v165 = CMPQconst <flags> [64] v151, func Int
crypto/rand/util.go:129: Inner loop invariant, header b14, val v164 = SBBQcarrymask <int> v165, func Int
crypto/rand/util.go:129: Inner loop invariant, header b14, val v102 = ANDQ <int> v163 v164, func Int
crypto/rand/util.go:129: Inner loop invariant, header b14, val v104 = ADDQconst <int> [-1] v102, func Int
crypto/rsa
# encoding/asn1
encoding/asn1/asn1.go:184: Inner loop invariant, header b10, val v44 = CMPQconst <flags> [32] v78, func BitString.RightAlign
encoding/asn1/asn1.go:184: Inner loop invariant, header b10, val v51 = SBBLcarrymask <byte> v44, func BitString.RightAlign
encoding/asn1/asn1.go:184: Inner loop invariant, header b10, val v118 = ADDQconst <uint> [-8] v11, func BitString.RightAlign
encoding/asn1/asn1.go:184: Inner loop invariant, header b10, val v78 = NEGQ <uint> v118, func BitString.RightAlign
encoding/asn1/asn1.go:845: Inner loop invariant, header b332, val v1282 = ADDQconst <*reflect.StructField> [24] v2, func parseField
encoding/asn1/asn1.go:859: Inner loop invariant, header b347, val v1357 = ADDQconst <*reflect.StructField> [24] v2, func parseField
encoding/asn1/marshal.go:120: Inner loop invariant, header b2, val v20 = ADDQconst <int> [-1] v12, func int64Encoder.Encode
encoding/asn1/marshal.go:431: Inner loop invariant, header b89, val v659 = ADDQconst <*reflect.StructField> [24] v2, func makeBody
crypto/ecdsa
# crypto/rsa
crypto/rsa/pkcs1v15.go:183: Inner loop invariant, header b12, val v75 = NEGQ <int> v52, func nonZeroRandomBytes
crypto/rsa/pkcs1v15.go:183: Inner loop invariant, header b12, val v54 = SARQconst <int> [63] v75, func nonZeroRandomBytes
crypto/rsa/pkcs1v15.go:183: Inner loop invariant, header b12, val v55 = ANDQ <int> v26 v54, func nonZeroRandomBytes
crypto/rsa/pkcs1v15.go:183: Inner loop invariant, header b12, val v56 = ADDQ <*byte> v77 v55, func nonZeroRandomBytes
crypto/rsa/pkcs1v15.go:183: Inner loop invariant, header b12, val v87 = CMPQ <flags> v26 v42, func nonZeroRandomBytes
crypto/rsa/pkcs1v15.go:183: Inner loop invariant, header b12, val v52 = SUBQ <int> v85 v26, func nonZeroRandomBytes
crypto/rsa/pkcs1v15.go:183: Inner loop invariant, header b12, val v42 = ADDQconst <int> [1] v26, func nonZeroRandomBytes
crypto/rsa/pkcs1v15.go:243: Inner loop invariant, header b8, val v91 = SUBQ <int> v54 v39, func SignPKCS1v15
crypto/rsa/pkcs1v15.go:243: Inner loop invariant, header b8, val v92 = ADDQconst <int> [-1] v91, func SignPKCS1v15
crypto/x509/pkix
encoding/csv
# crypto/x509/pkix
crypto/x509/pkix/pkix.go:69: Inner loop invariant, header b9, val v46 = ADDQconst <*[]AttributeTypeAndValue> [200] v6, func (*Name).FillFromRDNSequence
encoding/gob
# encoding/csv
encoding/csv/reader.go:256: Inner loop invariant, header b20, val v164 = ADDQconst <*[]int> [152] v7, func (*Reader).parseRecord
encoding/csv/reader.go:281: Inner loop invariant, header b42, val v318 = ADDQconst <int> [-1] v257, func (*Reader).parseRecord
encoding/csv/reader.go:347: Inner loop invariant, header b34, val v306 = ADDQconst <*bytes.Buffer> [48] v8, func (*Reader).parseField
encoding/csv/reader.go:353: Inner loop invariant, header b34, val v329 = ADDQconst <*bytes.Buffer> [48] v8, func (*Reader).parseField
encoding/csv/reader.go:359: Inner loop invariant, header b69, val v340 = ADDQconst <*bytes.Buffer> [48] v8, func (*Reader).parseField
encoding/json
encoding/xml
# encoding/json
encoding/json/decode.go:353: Inner loop invariant, header b3, val v67 = ADDQconst <*scanner> [32] v7, func (*decodeState).scanWhile
encoding/json/decode.go:535: Inner loop invariant, header b33, val v262 = ADDQconst <*scanner> [32] v6, func (*decodeState).array
encoding/json/decode.go:538: Inner loop invariant, header b33, val v436 = CMPQconst <flags> [23] v130, func (*decodeState).array
encoding/json/decode.go:1039: Inner loop invariant, header b3, val v42 = ADDQconst <*scanner> [32] v6, func (*decodeState).arrayInterface
encoding/json/encode.go:850: Inner loop invariant, header b2, val v62 = ADDQconst <*reflect.StructField> [24] v2, func typeByIndex
encoding/json/encode.go:1063: Inner loop invariant, header b4, val v121 = CMPQ <flags> v10 v132, func byIndex.Less
encoding/json/encode.go:1063: Inner loop invariant, header b4, val v112 = MULQconst <int> [104] v10, func byIndex.Less
encoding/json/encode.go:1103: Inner loop invariant, header b19, val v675 = ADDQconst <*reflect.StructField> [24] v2, func typeFields
encoding/json/indent.go:15: Inner loop invariant, header b8, val v198 = TESTB <flags> v10 v10, func compact
vendor/golang_org/x/net/http2/hpack
# vendor/golang_org/x/net/http2/hpack
vendor/golang_org/x/net/http2/hpack/huffman.go:86: Inner loop invariant, header b22, val v52 = TESTQ <flags> v9 v9, func huffmanDecode
vendor/golang_org/x/net/http2/hpack/huffman.go:143: Inner loop invariant, header b16, val v113 = ADDQ <int> v108 v106, func addDecoderNode
vendor/golang_org/x/net/idna
vendor/golang_org/x/text/unicode/norm
# encoding/gob
encoding/gob/decode.go:1113: Inner loop invariant, header b22, val v644 = ADDQconst <*reflect.StructField> [32] v2, func (*Decoder).compileDec
encoding/gob/decoder.go:137: Inner loop invariant, header b2, val v54 = TESTB <flags> v8 v8, func (*Decoder).decodeTypeSequence
encoding/gob/decoder.go:139: Inner loop invariant, header b2, val v20 = ADDQconst <*decBuffer> [24] v7, func (*Decoder).decodeTypeSequence
encoding/gob/encode.go:350: Inner loop invariant, header b19, val v211 = TESTQ <flags> v15 v15, func (*Encoder).encodeArray
encoding/gob/encode.go:644: Inner loop invariant, header b8, val v41 = ADDQconst <*reflect.StructField> [24] v2, func compileEnc
encoding/gob/encoder.go:120: Inner loop invariant, header b30, val v391 = ADDQconst <*reflect.StructField> [24] v2, func (*Encoder).sendActualType
encoding/gob/type.go:536: Inner loop invariant, header b123, val v1130 = ADDQconst <*reflect.StructField> [24] v2, func newTypeObject
encoding/gob/type.go:557: Inner loop invariant, header b123, val v988 = ADDQconst <*[]*fieldType> [24] v774, func newTypeObject
vendor/golang_org/x/text/width
mime
mime/quotedprintable
# encoding/xml
encoding/xml/read.go:504: Inner loop invariant, header b230, val v2028 = TESTQ <flags> v1734 v1734, func (*Decoder).unmarshal
encoding/xml/xml.go:271: Inner loop invariant, header b42, val v345 = ADDQconst <**stack> [200] v7, func (*Decoder).Token
encoding/xml/xml.go:277: Inner loop invariant, header b42, val v528 = ADDQconst <**stack> [200] v7, func (*Decoder).Token
encoding/xml/xml.go:462: Inner loop invariant, header b36, val v392 = ADDQconst <**stack> [200] v7, func (*Decoder).popElement
net/http/internal
# mime/quotedprintable
mime/quotedprintable/reader.go:83: Inner loop invariant, header b2, val v18 = ADDQconst <*[]byte> [24] v8, func (*Reader).Read
net/url
# net/http/internal
net/http/internal/chunked.go:79: Inner loop invariant, header b2, val v71 = ADDQconst <**uint8> [24] v8, func (*chunkedReader).Read
net/http/internal/chunked.go:79: Inner loop invariant, header b2, val v44 = ADDQconst <*[2]byte> [32] v8, func (*chunkedReader).Read
net/http/internal/chunked.go:104: Inner loop invariant, header b2, val v217 = ADDQconst <**uint8> [24] v8, func (*chunkedReader).Read
text/template/parse
# net/url
net/url/url.go:205: Inner loop invariant, header b2, val v98 = CMPQconst <flags> [3] v9, func unescape
net/url/url.go:208: Inner loop invariant, header b2, val v37 = CMPQconst <flags> [4] v9, func unescape
net/url/url.go:295: Inner loop invariant, header b18, val v176 = CMPQconst <flags> [6] v8, func escape
go/constant
# cmd/cgo
cmd/cgo/ast.go:88: Inner loop invariant, header b13, val v235 = ADDQconst <*string> [48] v6, func (*File).ReadGo
cmd/cgo/gcc.go:2203: Inner loop invariant, header b114, val v1506 = TESTQ <flags> v1416 v1416, func (*typeConv).Struct
go/format
# vendor/golang_org/x/text/unicode/norm
vendor/golang_org/x/text/unicode/norm/composition.go:162: Inner loop invariant, header b2, val v64 = ADDQconst <*[]byte> [520] v6, func appendFlush
vendor/golang_org/x/text/unicode/norm/composition.go:162: Inner loop invariant, header b2, val v43 = ADDQconst <*[128]byte> [256] v6, func appendFlush
vendor/golang_org/x/text/unicode/norm/composition.go:172: Inner loop invariant, header b2, val v45 = ADDQconst <*[128]byte> [256] v7, func (*reorderBuffer).flush
vendor/golang_org/x/text/unicode/norm/composition.go:184: Inner loop invariant, header b2, val v61 = ADDQconst <*[128]byte> [256] v7, func (*reorderBuffer).flushCopy
vendor/golang_org/x/text/unicode/norm/composition.go:261: Inner loop invariant, header b3, val v25 = ADDQconst <*input> [8] v2, func (*reorderBuffer).insertDecomposed
vendor/golang_org/x/text/unicode/norm/composition.go:261: Inner loop invariant, header b3, val v22 = ADDQconst <*input> [488] v7, func (*reorderBuffer).insertDecomposed
vendor/golang_org/x/text/unicode/norm/composition.go:265: Inner loop invariant, header b3, val v105 = ADDQconst <*[128]byte> [256] v7, func (*reorderBuffer).insertDecomposed
vendor/golang_org/x/text/unicode/norm/composition.go:482: Inner loop invariant, header b6, val v55 = ADDQconst <*[128]byte> [256] v5, func (*reorderBuffer).compose
vendor/golang_org/x/text/unicode/norm/iter.go:185: Inner loop invariant, header b11, val v23 = ADDQconst <*input> [8] v2, func nextMulti
vendor/golang_org/x/text/unicode/norm/iter.go:212: Inner loop invariant, header b2, val v177 = ADDQconst <*streamSafe> [385] v6, func nextMultiNorm
vendor/golang_org/x/text/unicode/norm/iter.go:213: Inner loop invariant, header b2, val v126 = ADDQconst <*input> [16] v2, func nextMultiNorm
vendor/golang_org/x/text/unicode/norm/iter.go:280: Inner loop invariant, header b7, val v729 = ADDQconst <*[128]byte> [552] v6, func nextDecomposed
vendor/golang_org/x/text/unicode/norm/iter.go:338: Inner loop invariant, header b3, val v12 = ADDQconst <*streamSafe> [385] v6, func doNormDecomposed
vendor/golang_org/x/text/unicode/norm/iter.go:342: Inner loop invariant, header b3, val v166 = ADDQconst <*input> [440] v6, func doNormDecomposed
vendor/golang_org/x/text/unicode/norm/iter.go:342: Inner loop invariant, header b3, val v70 = ADDQconst <*input> [16] v2, func doNormDecomposed
vendor/golang_org/x/text/unicode/norm/iter.go:387: Inner loop invariant, header b10, val v110 = ADDQconst <*input> [432] v6, func nextComposed
vendor/golang_org/x/text/unicode/norm/iter.go:391: Inner loop invariant, header b10, val v140 = ADDQconst <*input> [440] v6, func nextComposed
vendor/golang_org/x/text/unicode/norm/iter.go:391: Inner loop invariant, header b10, val v368 = ADDQconst <*input> [8] v2, func nextComposed
vendor/golang_org/x/text/unicode/norm/iter.go:426: Inner loop invariant, header b3, val v94 = ADDQconst <*input> [440] v6, func doNormComposed
vendor/golang_org/x/text/unicode/norm/iter.go:427: Inner loop invariant, header b3, val v78 = ADDQconst <*streamSafe> [385] v6, func doNormComposed
vendor/golang_org/x/text/unicode/norm/iter.go:433: Inner loop invariant, header b3, val v14 = ADDQconst <*input> [16] v2, func doNormComposed
vendor/golang_org/x/text/unicode/norm/normalize.go:85: Inner loop invariant, header b9, val v154 = ADDQconst <*formInfo> [400] v70, func Form.IsNormal
vendor/golang_org/x/text/unicode/norm/normalize.go:85: Inner loop invariant, header b9, val v193 = ADDQconst <*input> [440] v70, func Form.IsNormal
vendor/golang_org/x/text/unicode/norm/normalize.go:139: Inner loop invariant, header b9, val v161 = ADDQconst <*formInfo> [400] v77, func Form.IsNormalString
vendor/golang_org/x/text/unicode/norm/normalize.go:139: Inner loop invariant, header b9, val v215 = ADDQconst <*input> [440] v77, func Form.IsNormalString
vendor/golang_org/x/text/unicode/norm/normalize.go:380: Inner loop invariant, header b7, val v63 = ADDQconst <*input> [8] v2, func Form.firstBoundary
vendor/golang_org/x/text/unicode/norm/normalize.go:535: Inner loop invariant, header b16, val v172 = ADDQconst <*streamSafe> [385] v8, func decomposeSegment
vendor/golang_org/x/text/unicode/norm/normalize.go:605: Inner loop invariant, header b42, val v92 = ADDQconst <*input> [16] v2, func decomposeToLastBoundary
vendor/golang_org/x/text/unicode/norm/readwriter.go:28: Inner loop invariant, header b2, val v51 = ADDQconst <*input> [432] v8, func (*normWriter).Write
vendor/golang_org/x/text/unicode/norm/readwriter.go:30: Inner loop invariant, header b2, val v61 = ADDQconst <*[]byte> [568] v8, func (*normWriter).Write
vendor/golang_org/x/text/unicode/norm/readwriter.go:36: Inner loop invariant, header b2, val v105 = ADDQconst <*formInfo> [400] v8, func (*normWriter).Write
vendor/golang_org/x/text/unicode/norm/readwriter.go:93: Inner loop invariant, header b3, val v171 = ADDQconst <**uint8> [640] v8, func (*normReader).Read
vendor/golang_org/x/text/unicode/norm/readwriter.go:96: Inner loop invariant, header b3, val v123 = ADDQconst <*[]byte> [592] v8, func (*normReader).Read
vendor/golang_org/x/text/unicode/norm/readwriter.go:101: Inner loop invariant, header b3, val v241 = ADDQconst <*input> [432] v8, func (*normReader).Read
vendor/golang_org/x/text/unicode/norm/transform.go:61: Inner loop invariant, header b7, val v93 = ADDQconst <*[]byte> [520] v22, func Form.transform
vendor/golang_org/x/text/unicode/norm/transform.go:61: Inner loop invariant, header b7, val v95 = ADDQconst <*int> [528] v22, func Form.transform
vendor/golang_org/x/text/unicode/norm/transform.go:61: Inner loop invariant, header b7, val v103 = ADDQconst <*func(*reorderBuffer) bool> [544] v22, func Form.transform
vendor/golang_org/x/text/unicode/norm/transform.go:77: Inner loop invariant, header b7, val v94 = ADDQconst <*input> [16] v2, func Form.transform
vendor/golang_org/x/text/unicode/norm/transform.go:77: Inner loop invariant, header b7, val v76 = ADDQconst <*input> [440] v22, func Form.transform
go/types
text/scanner
# text/template/parse
text/template/parse/node.go:110: Inner loop invariant, header b6, val v70 = ADDQconst <*[]Node> [24] v26, func (*ListNode).CopyList
text/template/parse/node.go:191: Inner loop invariant, header b4, val v235 = CMPQ <flags> v140 v140, func (*PipeNode).CopyPipe
text/template/parse/node.go:195: Inner loop invariant, header b24, val v281 = ADDQconst <*[]*CommandNode> [56] v214, func (*PipeNode).CopyPipe
text/template/parse/node.go:274: Inner loop invariant, header b7, val v73 = ADDQconst <*[]Node> [24] v29, func (*CommandNode).Copy
text/template/parse/parse.go:282: Inner loop invariant, header b12, val v780 = ADDQconst <*item> [96] v5, func (*Tree).parse
text/template/parse/parse.go:283: Inner loop invariant, header b12, val v788 = ADDQconst <*item> [96] v5, func (*Tree).parse
text/template/parse/parse.go:285: Inner loop invariant, header b12, val v738 = ADDQconst <*item> [16] v2, func (*Tree).parse
text/template/parse/parse.go:336: Inner loop invariant, header b4, val v88 = ADDQconst <*[]Node> [24] v26, func (*Tree).itemList
text/template/parse/parse.go:398: Inner loop invariant, header b3, val v831 = ADDQconst <*item> [96] v7, func (*Tree).pipeline
text/template/parse/parse.go:403: Inner loop invariant, header b3, val v304 = ADDQconst <*[]string> [216] v7, func (*Tree).pipeline
text/template/parse/parse.go:405: Inner loop invariant, header b3, val v855 = CMPQconst <flags> [5] v714, func (*Tree).pipeline
text/template/parse/parse.go:599: Inner loop invariant, header b5, val v56 = ADDQconst <*[]Node> [24] v24, func (*Tree).command
text/template/parse/parse.go:632: Inner loop invariant, header b24, val v642 = ADDQconst <*item> [96] v6, func (*Tree).operand
text/template
# text/scanner
text/scanner/scanner.go:222: Inner loop invariant, header b6, val v95 = ADDQconst <*bytes.Buffer> [1104] v6, func (*Scanner).next
image/gif
# image/gif
image/gif/reader.go:474: Inner loop invariant, header b14, val v143 = MULQ <int> v96 v57, func uninterlace
image/gif/writer.go:82: Inner loop invariant, header b7, val v43 = ADDQconst <*[256]byte> [160] v115, func blockWriter.Write
image/gif/writer.go:82: Inner loop invariant, header b7, val v54 = ADDQconst <*byte> [161] v115, func blockWriter.Write
image/gif/writer.go:263: Inner loop invariant, header b121, val v813 = ADDQconst <**uint8> [24] v8, func (*encoder).writeImageBlock
image/png
runtime/cgo
# image/png
image/png/reader.go:337: Inner loop invariant, header b5, val v43 = ADDQconst <*[768]byte> [116] v8, func (*decoder).Read
image/png/reader.go:341: Inner loop invariant, header b5, val v160 = ADDQconst <*byte> [120] v8, func (*decoder).Read
image/png/reader.go:392: Inner loop invariant, header b23, val v208 = ADDQconst <*[768]byte> [116] v7, func (*decoder).decode
index/suffixarray
# index/suffixarray
index/suffixarray/qsufsort.go:110: Inner loop invariant, header b6, val v93 = TESTQ <flags> v242 v242, func initGroups
index/suffixarray/qsufsort.go:161: Inner loop invariant, header b27, val v199 = LEAQ1 <int> [-1] v7 v190, func (*suffixSortable).updateGroups
internal/pprof/profile
net
# text/template
text/template/exec.go:413: Inner loop invariant, header b17, val v153 = ADDQconst <*[]variable> [40] v8, func (*state).evalPipeline
text/template/exec.go:522: Inner loop invariant, header b2, val v28 = ADDQconst <int> [-1] v20, func (*state).evalFieldChain
text/template/funcs.go:253: Inner loop invariant, header b36, val v394 = ADDQconst <int> [-1] v179, func call
go/doc
# internal/pprof/profile
internal/pprof/profile/filter.go:18: Inner loop invariant, header b2, val v211 = TESTQ <flags> v13 v13, func (*Profile).FilterSamplesByName
internal/pprof/profile/filter.go:25: Inner loop invariant, header b2, val v200 = TESTQ <flags> v14 v14, func (*Profile).FilterSamplesByName
internal/pprof/profile/filter.go:139: Inner loop invariant, header b6, val v139 = TESTQ <flags> v11 v11, func focusedSample
internal/pprof/profile/filter.go:149: Inner loop invariant, header b22, val v58 = TESTQ <flags> v11 v11, func focusedSample
internal/pprof/profile/legacy_profile.go:426: Inner loop invariant, header b22, val v454 = TESTB <flags> v13 v13, func parseCPUSamples
internal/pprof/profile/profile.go:290: Inner loop invariant, header b29, val v24 = TESTB <flags> v15 v15, func (*Profile).Aggregate
internal/pprof/profile/profile.go:290: Inner loop invariant, header b29, val v273 = TESTB <flags> v16 v16, func (*Profile).Aggregate
internal/pprof/profile/profile.go:290: Inner loop invariant, header b17, val v188 = TESTB <flags> v14 v14, func (*Profile).Aggregate
internal/pprof/profile/proto.go:49: Inner loop invariant, header b2, val v18 = ADDQconst <*[]byte> [24] v6, func encodeVarint
html/template
# go/doc
go/doc/comment.go:28: Inner loop invariant, header b4, val v15 = ADDQconst <int> [-1] v157, func commentEscape
go/doc/comment.go:137: Inner loop invariant, header b3, val v201 = TESTQ <flags> v10 v10, func emphasize
go/doc/example.go:278: Inner loop invariant, header b151, val v975 = ADDQconst <*[]ast.Spec> [32] v847, func playExample
go/doc/exports.go:88: Inner loop invariant, header b4, val v126 = ADDQconst <*[]*ast.InterfaceType> [120] v9, func (*reader).filterFieldList
go/doc/reader.go:554: Inner loop invariant, header b11, val v269 = TESTQconst <flags> [1] v9, func (*reader).readPackage
go/doc/synopsis.go:46: Inner loop invariant, header b2, val v122 = TESTQconst <flags> [1] v8, func clean
go/build
testing
# go/build
go/build/build.go:785: Inner loop invariant, header b575, val v3314 = TESTB <flags> v5716 v5716, func (*Context).Import
go/build/build.go:883: Inner loop invariant, header b670, val v5010 = ADDQconst <*[]string> [184] v21, func (*Context).Import
go/build/read.go:96: Inner loop invariant, header b46, val v157 = ADDQconst <**uint8> [48] v7, func (*importReader).peekByte
internal/trace
# testing
testing/benchmark.go:440: Inner loop invariant, header b2, val v48 = ADDQconst <*int> [8] v6, func (*benchContext).processBench
testing/benchmark.go:455: Inner loop invariant, header b2, val v124 = ADDQconst <*BenchmarkResult> [16] v2, func (*benchContext).processBench
testing/benchmark.go:551: Inner loop invariant, header b2, val v11 = ADDQconst <*[]byte> [24] v5, func (*B).trimOutput
testing/cover.go:98: Inner loop invariant, header b12, val v264 = TESTQ <flags> v431 v431, func coverReport
testing/testing.go:366: Inner loop invariant, header b2, val v37 = ADDQconst <*[]byte> [24] v168, func indenter.Write
internal/testenv
# internal/trace
internal/trace/parser.go:208: Inner loop invariant, header b86, val v976 = MOVBQZX <int> v1545, func readTrace
internal/trace/parser.go:363: Inner loop invariant, header b143, val v1033 = ADDQconst <int> [-1] v231, func parseEvents
internal/trace/parser.go:423: Inner loop invariant, header b234, val v664 = TESTQ <flags> v1664 v1664, func parseEvents
runtime/pprof
net/internal/socktest
# go/types
go/types/call.go:201: Inner loop invariant, header b22, val v201 = ADDQconst <int> [-1] v15, func (*Checker).arguments
go/types/check.go:184: Inner loop invariant, header b2, val v85 = ADDQconst <*string> [16] v63, func (*Checker).initFiles
go/types/initorder.go:218: Inner loop invariant, header b12, val v218 = ADDQconst <*nodeSet> [24] v130, func dependencyGraph
go/types/initorder.go:242: Inner loop invariant, header b40, val v431 = ADDQconst <*nodeSet> [24] v394, func dependencyGraph
go/types/methodset.go:245: Inner loop invariant, header b7, val v192 = ADDQconst <int> [1] v367, func methodSet.add
go/types/methodset.go:245: Inner loop invariant, header b7, val v267 = SHLQconst <uintptr> [3] v367, func methodSet.add
go/types/resolver.go:324: Inner loop invariant, header b260, val v1998 = TESTQ <flags> v3313 v3313, func (*Checker).collectObjects
go/types/scope.go:86: Inner loop invariant, header b2, val v79 = TESTQ <flags> v11 v11, func (*Scope).LookupParent
go/types/scope.go:178: Inner loop invariant, header b20, val v245 = ADDQconst <int> [1] v10, func (*Scope).WriteTo
go/types/stmt.go:540: Inner loop invariant, header b412, val v2081 = ADDQconst <**Scope> [160] v7, func (*Checker).stmt
go/types/stmt.go:643: Inner loop invariant, header b501, val v2776 = ADDQconst <**Scope> [160] v7, func (*Checker).stmt
go/types/stmt.go:702: Inner loop invariant, header b546, val v3074 = ADDQconst <**Scope> [160] v7, func (*Checker).stmt
go/types/stmt.go:845: Inner loop invariant, header b764, val v4127 = ADDQconst <**uint8> [32] v3288, func (*Checker).stmt
go/types/typestring.go:238: Inner loop invariant, header b4, val v263 = TESTB <flags> v11 v11, func writeTuple
go/types/typexpr.go:506: Inner loop invariant, header b6, val v311 = ADDQconst <*[]*Func> [48] v10, func (*Checker).interfaceType
go/internal/gccgoimporter
go/internal/gcimporter
# runtime/pprof
runtime/pprof/proto.go:130: Inner loop invariant, header b2, val v145 = ADDQconst <*[]*profile.Function> [96] v5, func symbolize
os/user
# go/internal/gccgoimporter
go/internal/gccgoimporter/gccgoinstallation.go:52: Inner loop invariant, header b41, val v264 = ADDQconst <*[]string> [32] v7, func (*GccgoInstallation).InitFromDriver
go/internal/gccgoimporter/parser.go:782: Inner loop invariant, header b52, val v241 = ADDQconst <*[]PackageInit> [1416] v5, func (*parser).parseInitDataDirective
go/internal/gccgoimporter/parser.go:782: Inner loop invariant, header b52, val v187 = ADDQconst <*PackageInit> [16] v2, func (*parser).parseInitDataDirective
# go/internal/gcimporter
go/internal/gcimporter/bimport.go:829: Inner loop invariant, header b5, val v37 = ADDQconst <*[]byte> [48] v7, func (*importer).rawStringln
plugin
go/importer
testing/internal/testdeps
testing/iotest
# testing/iotest
testing/iotest/reader.go:57: Inner loop invariant, header b3, val v15 = ADDQconst <*[]byte> [16] v8, func (*dataErrReader).Read
testing/quick
# testing/quick
testing/quick/quick.go:160: Inner loop invariant, header b153, val v428 = ADDQconst <*reflect.StructField> [24] v2, func sizedValue
cmd/api
cmd/internal/obj/arm
# cmd/api
cmd/api/goapi.go:182: Inner loop invariant, header b120, val v346 = CMPQ <flags> v856 v1494, func main
cmd/api/goapi.go:182: Inner loop invariant, header b120, val v910 = ADDQ <*uint8> v1507 v909, func main
cmd/api/goapi.go:182: Inner loop invariant, header b120, val v906 = SUBQ <int> v1494 v856, func main
cmd/api/goapi.go:182: Inner loop invariant, header b120, val v168 = NEGQ <int> v906, func main
cmd/api/goapi.go:182: Inner loop invariant, header b120, val v908 = SARQconst <int> [63] v168, func main
cmd/api/goapi.go:182: Inner loop invariant, header b120, val v909 = ANDQ <int> v908 v856, func main
cmd/internal/obj/arm64
# cmd/internal/obj/arm
cmd/internal/obj/arm/asm5.go:658: Inner loop invariant, header b68, val v501 = ADDQconst <**obj.Prog> [192] v6, func span5
cmd/internal/obj/mips
cmd/internal/obj/ppc64
# cmd/internal/obj/arm64
cmd/internal/obj/arm64/asm7.go:550: Inner loop invariant, header b7, val v70 = ADDQconst <**obj.Prog> [192] v6, func span7
cmd/internal/obj/s390x
# net
net/addrselect.go:46: Inner loop invariant, header b2, val v65 = ADDQconst <*string> [32] v24, func srcAddrs
net/dnsclient_unix.go:191: Inner loop invariant, header b10, val v130 = TESTL <flags> v339 v339, func tryOneName
net/dnsmsg.go:256: Inner loop invariant, header b5, val v85 = ADDQconst <*string> [32] v7, func (*dnsRR_TXT).Walk
net/ipsock.go:89: Inner loop invariant, header b2, val v11 = TESTQ <flags> v10 v10, func filterAddrList
net/ipsock.go:89: Inner loop invariant, header b2, val v102 = ADDQconst <*IPAddr> [8] v2, func filterAddrList
net/parse.go:377: Inner loop invariant, header b2, val v20 = SUBQ <int> v128 v169, func goDebugString
net/parse.go:377: Inner loop invariant, header b2, val v22 = ADDQconst <int> [-1] v20, func goDebugString
net/tcpsock_posix.go:88: Inner loop invariant, header b2, val v97 = TESTQ <flags> v12 v12, func doDialTCP
net/nss.go:122: Inner loop invariant, header b16, val v323 = ADDQconst <*map[string][]nssSource> [16] v9, func parseNSSConf.func1
crypto/x509
# cmd/internal/obj/mips
cmd/internal/obj/mips/asm0.go:394: Inner loop invariant, header b25, val v113 = ADDQconst <**obj.Prog> [192] v6, func span0
vendor/golang_org/x/net/lex/httplex
net/textproto
mime/multipart
# mime/multipart
mime/multipart/multipart.go:173: Inner loop invariant, header b2, val v37 = ADDQconst <*int> [40] v18, func partReader.Read
mime/multipart/multipart.go:174: Inner loop invariant, header b2, val v96 = ADDQconst <**uint8> [80] v232, func partReader.Read
mime/multipart/multipart.go:174: Inner loop invariant, header b2, val v140 = ADDQconst <**uint8> [96] v232, func partReader.Read
log/syslog
# cmd/internal/obj/ppc64
cmd/internal/obj/ppc64/asm9.go:574: Inner loop invariant, header b7, val v65 = ADDQconst <**obj.Prog> [192] v6, func span9
net/mail
cmd/internal/obj/x86
# net/mail
net/mail/message.go:200: Inner loop invariant, header b10, val v169 = ADDQconst <int> [-1] v383, func (*Address).String
cmd/asm/internal/flags
cmd/asm/internal/lex
cmd/internal/bio
cmd/compile/internal/syntax
# cmd/internal/obj/s390x
cmd/internal/obj/s390x/asmz.go:418: Inner loop invariant, header b16, val v152 = ADDQconst <**obj.Prog> [192] v6, func spanz
cmd/internal/gcprog
cmd/internal/browser
# crypto/x509
crypto/x509/verify.go:539: Inner loop invariant, header b31, val v34 = CMPQconst <flags> [1] v114, func checkChainForKeyUsage
crypto/x509/x509.go:1242: Inner loop invariant, header b152, val v1085 = ADDQconst <*[]string> [1088] v15, func parseCertificate
crypto/x509/x509.go:2246: Inner loop invariant, header b14, val v348 = ADDQconst <*[]string> [504] v50, func parseCertificateRequest
crypto/x509/x509.go:2246: Inner loop invariant, header b14, val v358 = ADDQconst <*[]net.IP> [528] v50, func parseCertificateRequest
crypto/tls
cmd/cover
# cmd/internal/obj/x86
cmd/internal/obj/x86/asm6.go:3414: Inner loop invariant, header b498, val v1736 = ADDQconst <*obj.AsmBuf> [272] v6, func doasm
cmd/internal/obj/x86/asm6.go:3423: Inner loop invariant, header b510, val v1776 = ADDQconst <*obj.AsmBuf> [272] v6, func doasm
cmd/internal/obj/x86/asm6.go:3461: Inner loop invariant, header b544, val v2115 = ADDQconst <*obj.AsmBuf> [272] v6, func doasm
cmd/internal/obj/x86/asm6.go:3886: Inner loop invariant, header b1148, val v7177 = ADDQconst <*obj.AsmBuf> [272] v6, func doasm
cmd/internal/obj/x86/obj6.go:686: Inner loop invariant, header b45, val v2546 = CMPLconst <flags> [120] v3109, func preprocess
cmd/internal/obj/x86/obj6.go:944: Inner loop invariant, header b252, val v2167 = MOVLQSX <int64> v2166, func preprocess
cmd/internal/obj/x86/obj6.go:944: Inner loop invariant, header b252, val v2166 = NEGL <int32> v3109, func preprocess
cmd/asm/internal/arch
cmd/asm/internal/asm
# cmd/cover
cmd/cover/cover.go:747: Inner loop invariant, header b12, val v289 = ADDQconst <*string> [8] v6, func (*File).addVariables
cmd/cover/cover.go:768: Inner loop invariant, header b48, val v363 = ADDQconst <*token.Position> [24] v2, func (*File).addVariables
# cmd/compile/internal/syntax
cmd/compile/internal/syntax/dumper.go:184: Inner loop invariant, header b66, val v379 = ADDQconst <*reflect.StructField> [24] v2, func (*dumper).dump
cmd/compile/internal/syntax/parser.go:202: Inner loop invariant, header b13, val v77 = ADDQconst <*scanner> [16] v6, func (*parser).advance
cmd/compile/internal/syntax/parser.go:263: Inner loop invariant, header b23, val v182 = ADDQconst <*[]Decl> [8] v36, func (*parser).file
cmd/compile/internal/syntax/parser.go:521: Inner loop invariant, header b2, val v123 = ADDQconst <*scanner> [16] v7, func (*parser).binaryExpr
cmd/compile/internal/syntax/parser.go:917: Inner loop invariant, header b18, val v197 = ADDQconst <*scanner> [16] v6, func (*parser).complitexpr
cmd/compile/internal/syntax/parser.go:923: Inner loop invariant, header b18, val v234 = ADDQconst <*[]Expr> [16] v36, func (*parser).complitexpr
cmd/compile/internal/syntax/parser.go:1798: Inner loop invariant, header b23, val v182 = ADDQconst <*[]*CaseClause> [32] v36, func (*parser).switchStmt
cmd/compile/internal/syntax/parser.go:2040: Inner loop invariant, header b18, val v143 = ADDQconst <*[]Expr> [16] v38, func (*parser).call
cmd/compile/internal/syntax/source.go:97: Inner loop invariant, header b3, val v48 = ADDQconst <*[4096]byte> [24] v6, func (*source).getr
cmd/compile/internal/syntax/source.go:172: Inner loop invariant, header b21, val v208 = ADDQconst <*[4096]byte> [24] v5, func (*source).fill
cmd/compile/internal/ssa
# cmd/asm/internal/asm
cmd/asm/internal/asm/parse.go:136: Inner loop invariant, header b33, val v284 = TESTQ <flags> v732 v732, func (*Parser).line
cmd/asm/internal/asm/parse.go:210: Inner loop invariant, header b5, val v128 = ADDQconst <*[]obj.Addr> [136] v9, func (*Parser).instruction
cmd/asm
# cmd/asm
cmd/asm/main.go:61: Inner loop invariant, header b52, val v529 = ADDQconst <*func(string, ...interface {})> [408] v70, func main
cmd/asm/main.go:65: Inner loop invariant, header b52, val v539 = ADDQconst <*[]*obj.Plist> [128] v70, func main
cmd/dist
# crypto/tls
crypto/tls/conn.go:381: Inner loop invariant, header b12, val v90 = ADDQconst <int> [-1] v18, func padToBlockSize
crypto/tls/conn.go:584: Inner loop invariant, header b33, val v158 = ADDQconst <**block> [640] v7, func (*Conn).readRecord
crypto/tls/conn.go:608: Inner loop invariant, header b33, val v1127 = CMPBconst <flags> [22] v8, func (*Conn).readRecord
crypto/tls/conn.go:615: Inner loop invariant, header b33, val v414 = ADDQconst <*uint16> [56] v7, func (*Conn).readRecord
crypto/tls/conn.go:647: Inner loop invariant, header b33, val v879 = ADDQconst <*halfConn> [288] v7, func (*Conn).readRecord
crypto/tls/conn.go:676: Inner loop invariant, header b33, val v1091 = ADDQconst <**block> [360] v7, func (*Conn).readRecord
crypto/tls/conn.go:939: Inner loop invariant, header b6, val v13 = ADDQconst <*bytes.Buffer> [656] v7, func (*Conn).readHandshake
crypto/tls/conn.go:954: Inner loop invariant, header b33, val v208 = ADDQconst <int> [4] v121, func (*Conn).readHandshake
crypto/tls/conn.go:1019: Inner loop invariant, header b3, val v21 = ADDQconst <*int32> [808] v8, func (*Conn).Write
crypto/tls/conn.go:1133: Inner loop invariant, header b13, val v70 = ADDQconst <**block> [648] v8, func (*Conn).Read
crypto/tls/conn.go:1138: Inner loop invariant, header b13, val v104 = ADDQconst <*bytes.Buffer> [656] v8, func (*Conn).Read
crypto/tls/conn.go:1277: Inner loop invariant, header b5, val v79 = ADDQconst <**uint8> [48] v6, func (*Conn).Handshake
crypto/tls/conn.go:1283: Inner loop invariant, header b5, val v54 = ADDQconst <**sync.Cond> [32] v6, func (*Conn).Handshake
crypto/tls/prf.go:95: Inner loop invariant, header b10, val v61 = ADDLconst <byte> [65] v252, func prf30
net/http/httptrace
net/smtp
net/http
cmd/doc
# cmd/doc
cmd/doc/pkg.go:142: Inner loop invariant, header b18, val v188 = ADDQconst <*[]*doc.Value> [128] v170, func parsePackage
cmd/doc/pkg.go:143: Inner loop invariant, header b18, val v264 = ADDQconst <*[]*doc.Value> [176] v170, func parsePackage
cmd/doc/pkg.go:144: Inner loop invariant, header b18, val v340 = ADDQconst <*[]*doc.Func> [200] v170, func parsePackage
cmd/doc/pkg.go:175: Inner loop invariant, header b2, val v11 = ADDQconst <*bytes.Buffer> [88] v6, func (*Package).newlines
cmd/doc/pkg.go:544: Inner loop invariant, header b2, val v124 = TESTQ <flags> v109 v109, func (*Package).findTypes
cmd/doc/pkg.go:793: Inner loop invariant, header b43, val v302 = ADDQconst <*bytes.Buffer> [88] v8, func (*Package).printMethodDoc
cmd/fix
# cmd/dist
cmd/dist/test.go:454: Inner loop invariant, header b123, val v1579 = ADDQconst <*[]distTest> [184] v5, func (*tester).registerTests
cmd/go/internal/cfg
cmd/go/internal/str
cmd/go/internal/base
# cmd/go/internal/base
cmd/go/internal/base/base.go:168: Inner loop invariant, header b7, val v66 = ADDQconst <*scanner.Error> [8] v2, func ExpandScanner
cmd/go/internal/buildid
cmd/go/internal/load
cmd/go/internal/doc
cmd/go/internal/help
cmd/go/internal/tool
cmd/go/internal/version
cmd/gofmt
# cmd/go/internal/load
cmd/go/internal/load/pkg.go:1081: Inner loop invariant, header b449, val v3953 = ADDQconst <*[]*Package> [840] v9, func (*Package).load
cmd/go/internal/load/pkg.go:1083: Inner loop invariant, header b449, val v4006 = ADDQconst <*[]*PackageError> [672] v9, func (*Package).load
cmd/go/internal/work
cmd/go/internal/fix
cmd/go/internal/fmtcmd
cmd/link/internal/ld
# cmd/go/internal/work
cmd/go/internal/work/build.go:458: Inner loop invariant, header b101, val v661 = ADDQconst <*[]*Action> [8] v617, func runBuild
cmd/go/internal/work/build.go:806: Inner loop invariant, header b12, val v1471 = TESTQ <flags> v1707 v1707, func (*Builder).action1
cmd/go/internal/work/build.go:1029: Inner loop invariant, header b147, val v1115 = ADDQconst <*[]*Action> [8] v21, func (*Builder).libaction
cmd/go/internal/work/build.go:1960: Inner loop invariant, header b16, val v152 = ADDQconst <int> [-1] v67, func (*Builder).runOut
cmd/go/internal/work/build.go:1960: Inner loop invariant, header b16, val v86 = NEGQ <int> v153, func (*Builder).runOut
cmd/go/internal/work/build.go:1960: Inner loop invariant, header b16, val v156 = SARQconst <int> [63] v86, func (*Builder).runOut
cmd/go/internal/work/build.go:1960: Inner loop invariant, header b16, val v157 = ANDQconst <int> [16] v156, func (*Builder).runOut
cmd/go/internal/work/build.go:1960: Inner loop invariant, header b16, val v158 = ADDQ <*string> v157 v70, func (*Builder).runOut
cmd/go/internal/work/build.go:1960: Inner loop invariant, header b16, val v144 = CMPQconst <flags> [1] v67, func (*Builder).runOut
cmd/go/internal/work/build.go:1960: Inner loop invariant, header b16, val v153 = ADDQconst <int> [-1] v36, func (*Builder).runOut
cmd/go/internal/work/build.go:2244: Inner loop invariant, header b26, val v302 = SHLQconst <int> [4] v5, func gcToolchain.asm
cmd/go/internal/work/build.go:2244: Inner loop invariant, header b26, val v492 = ADDQconst <int> [3] v5, func gcToolchain.asm
cmd/go/internal/work/build.go:2244: Inner loop invariant, header b26, val v247 = CMPQ <flags> v492 v6, func gcToolchain.asm
cmd/go/internal/work/build.go:1162: Inner loop invariant, header b26, val v200 = ADDQconst <*actionQueue> [96] v8, func (*Builder).Do.func1
cmd/go/internal/work/build.go:1194: Inner loop invariant, header b5, val v68 = ADDQconst <*sync.Mutex> [80] v8, func (*Builder).Do.func2
cmd/go/internal/work/build.go:1195: Inner loop invariant, header b5, val v73 = ADDQconst <*actionQueue> [96] v8, func (*Builder).Do.func2
cmd/go/internal/envcmd
cmd/go/internal/clean
cmd/go/internal/generate
# net/http
net/http/cookie.go:122: Inner loop invariant, header b38, val v797 = ADDQconst <*[]string> [136] v218, func readSetCookies
net/http/fs.go:788: Inner loop invariant, header b19, val v358 = ADDQconst <int64> [-1] v9, func parseRange
net/http/h2_bundle.go:2828: Inner loop invariant, header b7, val v162 = ADDQconst <*sync.Cond> [8] v8, func (*http2pipe).Read
net/http/h2_bundle.go:5963: Inner loop invariant, header b4, val v38 = MOVLQZX <int> v119, func (*http2ClientConn).frameScratchBuffer
net/http/h2_bundle.go:6286: Inner loop invariant, header b19, val v216 = ADDQconst <*sync.Mutex> [384] v20, func (*http2clientStream).writeRequestBody
net/http/h2_bundle.go:6289: Inner loop invariant, header b19, val v537 = TESTB <flags> v499 v499, func (*http2clientStream).writeRequestBody
net/http/h2_bundle.go:6289: Inner loop invariant, header b19, val v257 = XORLconst <bool> [1] v67, func (*http2clientStream).writeRequestBody
net/http/h2_bundle.go:6346: Inner loop invariant, header b5, val v98 = ADDQconst <*http2flow> [184] v8, func (*http2clientStream).awaitFlowControl
net/http/h2_bundle.go:7160: Inner loop invariant, header b6, val v51 = ADDQconst <*sync.Mutex> [80] v7, func (*http2ClientConn).ping
net/http/header.go:188: Inner loop invariant, header b9, val v44 = SUBQ <int> v156 v148, func hasToken
net/http/header.go:206: Inner loop invariant, header b9, val v166 = NEGQ <int> v148, func hasToken
net/http/header.go:206: Inner loop invariant, header b9, val v143 = SARQconst <int> [63] v166, func hasToken
net/http/server.go:1807: Inner loop invariant, header b43, val v713 = ADDQconst <*"sync/atomic".Value> [112] v6, func (*conn).serve
net/http/transport.go:368: Inner loop invariant, header b97, val v837 = ADDQconst <*connectMethod> [24] v2, func (*Transport).RoundTrip
net/http/transport.go:561: Inner loop invariant, header b2, val v29 = ADDQconst <*string> [40] v5, func (*envOnce).init
net/http/transport.go:758: Inner loop invariant, header b5, val v183 = ADDQconst <*connLRU> [32] v8, func (*Transport).getIdleConn
net/http/transport.go:1476: Inner loop invariant, header b6, val v122 = ADDQconst <*sync.Mutex> [208] v5, func (*persistConn).readLoop
expvar
net/http/cgi
net/http/cookiejar
net/http/fcgi
# net/http/cookiejar
net/http/cookiejar/jar.go:254: Inner loop invariant, header b32, val v238 = ADDQconst <*entry> [80] v2, func (*Jar).setCookies
net/http/httptest
net/http/httputil
net/http/pprof
net/rpc
# net/http/httputil
net/http/httputil/reverseproxy.go:348: Inner loop invariant, header b5, val v95 = ADDQconst <*sync.Mutex> [24] v5, func (*maxLatencyWriter).flushLoop
cmd/go/internal/web
cmd/go/internal/bug
cmd/go/internal/get
# net/rpc
net/rpc/client.go:114: Inner loop invariant, header b2, val v41 = ADDQconst <*sync.Mutex> [56] v5, func (*Client).input
net/rpc/jsonrpc
cmd/go/internal/list
cmd/go/internal/run
cmd/go/internal/test
# cmd/go/internal/get
cmd/go/internal/get/vcs.go:630: Inner loop invariant, header b65, val v601 = TESTQ <flags> v12 v12, func repoRootFromVCSPaths
cmd/go/internal/vet
cmd/nm
# cmd/go/internal/test
cmd/go/internal/test/test.go:512: Inner loop invariant, header b129, val v837 = ADDQconst <*[]*work.Action> [8] v802, func runTest
cmd/go/internal/test/test.go:1326: Inner loop invariant, header b2, val v69 = ADDQconst <*bool> [88] v15, func loadTestFuncs
cmd/go/internal/test/test.go:1326: Inner loop invariant, header b2, val v71 = ADDQconst <*bool> [89] v15, func loadTestFuncs
cmd/go/internal/test/test.go:1331: Inner loop invariant, header b10, val v146 = ADDQconst <*bool> [90] v15, func loadTestFuncs
cmd/go/internal/test/test.go:1331: Inner loop invariant, header b10, val v148 = ADDQconst <*bool> [91] v15, func loadTestFuncs
cmd/go
cmd/objdump
cmd/pack
cmd/pprof/internal/plugin
cmd/pprof/internal/report
cmd/pprof/internal/svg
cmd/pprof/internal/tempfile
cmd/pprof/internal/fetch
cmd/pprof/internal/symbolizer
cmd/pprof/internal/symbolz
cmd/trace
# cmd/link/internal/ld
cmd/link/internal/ld/data.go:1237: Inner loop invariant, header b42, val v322 = ADDQconst <*gcprog.Writer> [16] v6, func (*GCProg).AddSym
cmd/link/internal/ld/data.go:1725: Inner loop invariant, header b360, val v2981 = ADDQconst <*string> [8] v2736, func (*Link).dodata
cmd/link/internal/ld/deadcode.go:88: Inner loop invariant, header b33, val v344 = TESTB <flags> v703 v703, func deadcode
cmd/link/internal/ld/dwarf.go:570: Inner loop invariant, header b10, val v98 = ADDQconst <**"cmd/internal/dwarf".DWAttr> [24] v68, func copychildrenexcept
cmd/link/internal/ld/elf.go:1482: Inner loop invariant, header b8, val v893 = TESTL <flags> v1048 v1048, func elfdynhash
cmd/link/internal/ld/ld.go:101: Inner loop invariant, header b2, val v22 = ADDQconst <*[]*Library> [72] v11, func addlibpath
cmd/link/internal/ld/ldelf.go:609: Inner loop invariant, header b213, val v1348 = TESTQ <flags> v5029 v5029, func ldelf
cmd/link/internal/ld/ldelf.go:928: Inner loop invariant, header b528, val v800 = TESTQ <flags> v5134 v5134, func ldelf
cmd/link/internal/ld/ldelf.go:966: Inner loop invariant, header b2, val v24 = TESTQ <flags> v55 v55, func section
cmd/link/internal/ld/ldmacho.go:581: Inner loop invariant, header b145, val v1227 = ADDQconst <*uint32> [64] v4724, func ldmacho
cmd/link/internal/ld/lib.go:411: Inner loop invariant, header b32, val v263 = ADDQconst <*[]*Library> [72] v5, func (*Link).loadlib
cmd/link/internal/ld/lib.go:949: Inner loop invariant, header b4, val v61 = ADDQconst <*Hostobj> [40] v2, func hostobjCopy
cmd/link/internal/ld/lib.go:1764: Inner loop invariant, header b111, val v685 = ADDQconst <int> [2] v10, func stkcheck
cmd/link/internal/ld/macho.go:826: Inner loop invariant, header b2, val v109 = ADDQconst <*[]byte> [184] v63, func Domacholink
cmd/link/internal/ld/macho_combine_dwarf.go:296: Inner loop invariant, header b4, val v175 = ADDQconst <*loadCmdReader> [8] v2, func machoUpdateSections
cmd/link/internal/ld/objfile.go:206: Inner loop invariant, header b30, val v383 = ADDQconst <*string> [24] v5, func (*objReader).loadObjFile
cmd/link/internal/ld/objfile.go:225: Inner loop invariant, header b44, val v485 = ADDQconst <*string> [24] v5, func (*objReader).loadObjFile
cmd/link/internal/ld/pcln.go:80: Inner loop invariant, header b6, val v37 = MOVLQSX <int> v19, func addvarint
cmd/link/internal/ld/pcln.go:118: Inner loop invariant, header b2, val v34 = ADDQconst <*[]*Symbol> [152] v7, func renumberfiles
cmd/link/internal/ld/pe.go:585: Inner loop invariant, header b59, val v544 = ADDQconst <**Symbol> [88] v510, func initdynimport
cmd/link/internal/amd64
# cmd/pprof/internal/report
cmd/pprof/internal/report/report.go:233: Inner loop invariant, header b13, val v239 = ADDQconst <*string> [40] v90, func annotateAssembly
cmd/pprof/internal/report/report.go:303: Inner loop invariant, header b58, val v228 = TESTQ <flags> v949 v949, func printTags
cmd/link/internal/arm
cmd/link/internal/arm64
# cmd/link/internal/amd64
cmd/link/internal/amd64/asm.go:74: Inner loop invariant, header b2, val v61 = ADDQconst <*[]byte> [184] v11, func gentext.func1
cmd/link/internal/mips
cmd/link/internal/mips64
cmd/link/internal/ppc64
cmd/link/internal/s390x
cmd/link/internal/x86
cmd/pprof/internal/commands
# cmd/link/internal/x86
cmd/link/internal/x86/asm.go:89: Inner loop invariant, header b2, val v61 = ADDQconst <*[]byte> [184] v11, func gentext.func1
cmd/link/internal/x86/asm.go:117: Inner loop invariant, header b2, val v61 = ADDQconst <*[]byte> [184] v11, func gentext.func2
cmd/link
cmd/pprof/internal/driver
cmd/vet/internal/cfg
# cmd/vet/internal/cfg
cmd/vet/internal/cfg/builder.go:61: Inner loop invariant, header b2, val v629 = ADDQconst <**Block> [16] v6, func (*builder).stmt
cmd/vet/internal/cfg/builder.go:208: Inner loop invariant, header b44, val v572 = ADDQconst <**Block> [16] v7, func (*builder).switchStmt
cmd/vet/internal/cfg/builder.go:265: Inner loop invariant, header b33, val v450 = ADDQconst <**Block> [16] v7, func (*builder).typeSwitchStmt
cmd/vet/internal/cfg/builder.go:313: Inner loop invariant, header b19, val v402 = ADDQconst <**Block> [16] v7, func (*builder).selectStmt
cmd/vet/internal/cfg/builder.go:316: Inner loop invariant, header b19, val v468 = ADDQconst <**targets> [32] v7, func (*builder).selectStmt
cmd/vet
cmd/pprof
# cmd/pprof
cmd/pprof/pprof.go:340: Inner loop invariant, header b6, val v291 = TESTQ <flags> v11 v11, func (*file).Symbols
# cmd/vet
cmd/vet/asmdecl.go:289: Inner loop invariant, header b179, val v1879 = TESTB <flags> v2501 v2501, func asmCheck
cmd/vet/lostcancel.go:124: Inner loop invariant, header b44, val v126 = ADDQconst <*token.Position> [24] v2, func checkLostCancel
cmd/vet/lostcancel.go:268: Inner loop invariant, header b2, val v70 = TESTQ <flags> v7 v7, func tupleContains
cmd/vet/print.go:277: Inner loop invariant, header b2, val v51 = ADDQconst <*[]byte> [40] v5, func (*formatState).parseFlags
cmd/vet/print.go:499: Inner loop invariant, header b31, val v272 = SUBQ <int> v723 v885, func (*File).okPrintfArg
cmd/vet/asmdecl.go:171: Inner loop invariant, header b8, val v160 = ADDQconst <*int> [48] v71, func asmCheck.func1
cmd/vet/asmdecl.go:171: Inner loop invariant, header b8, val v174 = ADDQconst <*int> [40] v71, func asmCheck.func1
# cmd/compile/internal/ssa
cmd/compile/internal/ssa/decompose.go:246: Inner loop invariant, header b28, val v416 = ADDQconst <*LocalSlot> [16] v2, func decomposeUser
cmd/compile/internal/ssa/decompose.go:246: Inner loop invariant, header b28, val v816 = ADDQconst <*LocalSlot> [64] v2, func decomposeUser
cmd/compile/internal/ssa/dom.go:147: Inner loop invariant, header b20, val v572 = CMPQ <flags> v152 v391, func (*Func).dominatorsLTOrig
cmd/compile/internal/ssa/lca.go:87: Inner loop invariant, header b70, val v367 = CMPQ <flags> v485 v352, func makeLCArange
cmd/compile/internal/ssa/lca.go:87: Inner loop invariant, header b70, val v442 = LEAQ2 <int> v662 v662, func makeLCArange
cmd/compile/internal/ssa/lca.go:87: Inner loop invariant, header b70, val v485 = ADDQconst <int> [-1] v662, func makeLCArange
cmd/compile/internal/ssa/lca.go:88: Inner loop invariant, header b70, val v274 = ADDQ <int> v149 v458, func makeLCArange
cmd/compile/internal/ssa/lca.go:88: Inner loop invariant, header b70, val v516 = SARQconst <int> [1] v274, func makeLCArange
cmd/compile/internal/ssa/lca.go:88: Inner loop invariant, header b70, val v267 = SARQconst <int> [63] v458, func makeLCArange
cmd/compile/internal/ssa/lca.go:88: Inner loop invariant, header b70, val v149 = SHRQconst <int> [63] v267, func makeLCArange
cmd/compile/internal/ssa/likelyadjust.go:460: Inner loop invariant, header b2, val v31 = ADDLconst <int16> [1] v7, func (*loop).setDepth
cmd/compile/internal/ssa/loopbce.go:277: Inner loop invariant, header b2, val v1179 = ADDQconst <*string> [16] v6, func removeBoundsChecks
cmd/compile/internal/ssa/loopsinvariants.go:37: Inner loop invariant, header b33, val v281 = ADDQconst <*string> [16] v5, func hoistloopiv
cmd/compile/internal/ssa/phiopt.go:79: Inner loop invariant, header b48, val v742 = ADDQconst <int> [-1] v941, func phiopt
cmd/compile/internal/ssa/phiopt.go:79: Inner loop invariant, header b48, val v333 = NEGQ <int> v742, func phiopt
cmd/compile/internal/ssa/print.go:148: Inner loop invariant, header b73, val v462 = ADDQconst <*LocalSlot> [16] v2, func fprintFunc
cmd/compile/internal/ssa/prove.go:602: Inner loop invariant, header b7, val v247 = TESTQconst <flags> [1] v466, func updateRestrictions
cmd/compile/internal/ssa/prove.go:606: Inner loop invariant, header b7, val v157 = ORQconst <relation> [4] v466, func updateRestrictions
cmd/compile/internal/ssa/prove.go:608: Inner loop invariant, header b7, val v235 = TESTQconst <flags> [4] v466, func updateRestrictions
cmd/compile/internal/ssa/prove.go:610: Inner loop invariant, header b7, val v250 = ORQconst <relation> [1] v466, func updateRestrictions
cmd/compile/internal/ssa/prove.go:612: Inner loop invariant, header b7, val v225 = TESTQconst <flags> [4] v466, func updateRestrictions
cmd/compile/internal/ssa/prove.go:616: Inner loop invariant, header b7, val v344 = ORQconst <relation> [1] v466, func updateRestrictions
cmd/compile/internal/ssa/prove.go:618: Inner loop invariant, header b7, val v196 = TESTQconst <flags> [1] v466, func updateRestrictions
cmd/compile/internal/ssa/prove.go:620: Inner loop invariant, header b7, val v437 = ORQconst <relation> [4] v466, func updateRestrictions
cmd/compile/internal/ssa/prove.go:723: Inner loop invariant, header b64, val v786 = XORQconst <relation> [7] v930, func simplifyBlock
cmd/compile/internal/ssa/regalloc.go:321: Inner loop invariant, header b2, val v13 = ADDQconst <*[]*Value> [144] v7, func (*regAllocState).setOrig
cmd/compile/internal/ssa/regalloc.go:652: Inner loop invariant, header b2, val v86 = ADDQconst <**use> [224] v6, func (*regAllocState).advanceUses
cmd/compile/internal/ssa/regalloc.go:959: Inner loop invariant, header b319, val v2640 = TESTQ <flags> v10106 v10106, func (*regAllocState).regalloc
cmd/compile/internal/ssa/regalloc.go:960: Inner loop invariant, header b319, val v2563 = ADDQconst <*[]*Value> [64] v10106, func (*regAllocState).regalloc
cmd/compile/internal/ssa/regalloc.go:1604: Inner loop invariant, header b1143, val v8425 = ADDQconst <**use> [224] v6, func (*regAllocState).regalloc
cmd/compile/internal/ssa/regalloc.go:2553: Inner loop invariant, header b12, val v61 = LEAQ8 <*[4]register> [4] v126 v24, func (*desiredState).add
cmd/compile/internal/ssa/sparsetree.go:94: Inner loop invariant, header b12, val v162 = ADDQconst <int> [1] v10, func SparseTree.treestructure1
cmd/compile/internal/ssa/stackalloc.go:155: Inner loop invariant, header b22, val v1218 = ADDQconst <*LocalSlot> [8] v2, func (*stackAllocState).stackalloc
cmd/compile/internal/ssa/stackalloc.go:354: Inner loop invariant, header b2, val v13 = ADDQconst <*[]Location> [96] v7, func (*Func).setHome
cmd/compile/internal/ssa/tighten.go:113: Inner loop invariant, header b130, val v169 = TESTQ <flags> v553 v553, func tighten
cmd/compile/internal/ssa/writebarrier.go:137: Inner loop invariant, header b124, val v912 = ADDQconst <*[]Edge> [16] v837, func writebarrier
cmd/compile/internal/gc
# cmd/compile/internal/gc
cmd/compile/internal/gc/alg.go:285: Inner loop invariant, header b130, val v1708 = ADDQconst <*Nodes> [24] v340, func genhash
cmd/compile/internal/gc/bexport.go:712: Inner loop invariant, header b55, val v588 = ADDQconst <*[]*Func> [32] v6, func (*exporter).typ
cmd/compile/internal/gc/bimport.go:475: Inner loop invariant, header b54, val v322 = ADDQconst <*[]*Node> [112] v6, func (*importer).typ
cmd/compile/internal/gc/bimport.go:1277: Inner loop invariant, header b5, val v37 = ADDQconst <*[]byte> [8] v7, func (*importer).rawStringln
cmd/compile/internal/gc/dcl.go:447: Inner loop invariant, header b8, val v277 = ADDQconst <*Nodes> [16] v7, func colasdefn
cmd/compile/internal/gc/esc.go:570: Inner loop invariant, header b6, val v175 = ADDQconst <*[]*Node> [208] v6, func (*EscState).escfunc
cmd/compile/internal/gc/esc.go:857: Inner loop invariant, header b414, val v927 = TESTQ <flags> v2917 v2917, func (*EscState).esc
cmd/compile/internal/gc/esc.go:1308: Inner loop invariant, header b31, val v112 = ADDLconst <uint16> [-1] v82, func describeEscape
cmd/compile/internal/gc/esc.go:1356: Inner loop invariant, header b29, val v226 = ADDLconst <uint16> [-1] v221, func (*EscState).escassignfromtag
cmd/compile/internal/gc/esc.go:1662: Inner loop invariant, header b208, val v1103 = CMPQconst <flags> [15] v1114, func (*EscState).esccall
cmd/compile/internal/gc/esc.go:1940: Inner loop invariant, header b280, val v3846 = CMPBconst <flags> [-2] v2583, func (*EscState).escwalkBody
cmd/compile/internal/gc/inl.go:746: Inner loop invariant, header b232, val v1598 = ADDQconst <*Nodes> [32] v1176, func mkinlcall1
cmd/compile/internal/gc/inl.go:752: Inner loop invariant, header b225, val v1634 = ADDQconst <*Nodes> [32] v1176, func mkinlcall1
cmd/compile/internal/gc/inl.go:764: Inner loop invariant, header b247, val v1719 = ADDQconst <*Nodes> [32] v1176, func mkinlcall1
cmd/compile/internal/gc/inl.go:776: Inner loop invariant, header b276, val v1880 = ADDQconst <*Nodes> [32] v1176, func mkinlcall1
cmd/compile/internal/gc/inl.go:796: Inner loop invariant, header b225, val v1395 = TESTB <flags> v3333 v3333, func mkinlcall1
cmd/compile/internal/gc/inl.go:796: Inner loop invariant, header b247, val v2673 = TESTB <flags> v3333 v3333, func mkinlcall1
cmd/compile/internal/gc/inl.go:987: Inner loop invariant, header b52, val v266 = ADDQconst <*Nodes> [32] v231, func (*inlsubst).node
cmd/compile/internal/gc/noder.go:890: Inner loop invariant, header b2, val v380 = TESTQ <flags> v10 v10, func (*noder).caseClauses
cmd/compile/internal/gc/pgen.go:125: Inner loop invariant, header b6, val v12 = ADDQconst <**obj.Prog> [8] v6, func removevardef
cmd/compile/internal/gc/pgen.go:129: Inner loop invariant, header b15, val v93 = ADDQconst <**uint8> [128] v6, func removevardef
cmd/compile/internal/gc/pgen.go:465: Inner loop invariant, header b4, val v363 = ADDQconst <**obj.Auto> [56] v6, func gendebug
cmd/compile/internal/gc/phi.go:197: Inner loop invariant, header b14, val v108 = ADDQconst <*[]*ssa.Block> [120] v9, func (*phiState).insertVarPhis
cmd/compile/internal/gc/plive.go:574: Inner loop invariant, header b4, val v105 = ADDQconst <*[]int32> [184] v5, func (*Liveness).initcache
cmd/compile/internal/gc/plive.go:576: Inner loop invariant, header b4, val v150 = ADDQconst <*[]int32> [160] v5, func (*Liveness).initcache
cmd/compile/internal/gc/plive.go:1404: Inner loop invariant, header b173, val v1452 = ADDQconst <*int64> [192] v1160, func livenessepilogue
cmd/compile/internal/gc/racewalk.go:94: Inner loop invariant, header b6, val v283 = TESTQ <flags> v7 v7, func instrumentlist
cmd/compile/internal/gc/sinit.go:733: Inner loop invariant, header b20, val v377 = CMPBconst <flags> [2] v10, func fixedlit
cmd/compile/internal/gc/sinit.go:733: Inner loop invariant, header b20, val v319 = TESTB <flags> v9 v9, func fixedlit
cmd/compile/internal/gc/sinit.go:744: Inner loop invariant, header b20, val v497 = CMPBconst <flags> [1] v10, func fixedlit
cmd/compile/internal/gc/sinit.go:744: Inner loop invariant, header b20, val v204 = CMPBconst <flags> [2] v10, func fixedlit
cmd/compile/internal/gc/ssa.go:318: Inner loop invariant, header b4, val v18 = ADDQconst <*[]map[*Node]*ssa.Value> [104] v6, func (*state).endBlock
cmd/compile/internal/gc/ssa.go:4640: Inner loop invariant, header b11, val v117 = TESTQ <flags> v283 v283, func CheckLoweredPhi
cmd/compile/internal/gc/subr.go:612: Inner loop invariant, header b67, val v416 = TESTB <flags> v11 v11, func eqtype1
cmd/compile/internal/gc/subr.go:1382: Inner loop invariant, header b40, val v77 = TESTB <flags> v12 v12, func lookdot0
cmd/compile/internal/gc/subr.go:1382: Inner loop invariant, header b19, val v24 = TESTB <flags> v12 v12, func lookdot0
cmd/compile/internal/gc/subr.go:1663: Inner loop invariant, header b6, val v480 = TESTB <flags> v8 v8, func structargs
cmd/compile/internal/gc/swt.go:119: Inner loop invariant, header b91, val v822 = TESTQ <flags> v342 v342, func typecheckswitch
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v308 = CVTSQ2SD <float64> v306, func (*lines).add
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v310 = DIVSD <float64> v308 v309, func (*lines).add
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v311 = ADDSD <float64> v310 v307, func (*lines).add
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v79 = SARQconst <time.Duration> [63] v13, func (*lines).add
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v306 = SUBQ <time.Duration> v13 v69, func (*lines).add
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v307 = CVTSQ2SD <float64> v303, func (*lines).add
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v69 = MULQconst <time.Duration> [1000000000] v303, func (*lines).add
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v114 = HMULQ <time.Duration> v111 v13, func (*lines).add
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v121 = SARQconst <time.Duration> [28] v114, func (*lines).add
cmd/compile/internal/gc/timings.go:181: Inner loop invariant, header b10, val v303 = SUBQ <time.Duration> v121 v79, func (*lines).add
cmd/compile/internal/gc/typecheck.go:2340: Inner loop invariant, header b6, val v26 = TESTQ <flags> v14 v14, func lookdot1
cmd/compile/internal/gc/typecheck.go:2343: Inner loop invariant, header b6, val v25 = CMPQconst <flags> [2] v14, func lookdot1
cmd/compile/internal/gc/typecheck.go:2976: Inner loop invariant, header b62, val v1392 = TESTQ <flags> v2314 v2314, func typecheckcomplit
cmd/compile/internal/gc/typecheck.go:3480: Inner loop invariant, header b21, val v30 = TESTQ <flags> v401 v401, func stringtoarraylit
cmd/compile/internal/gc/walk.go:1651: Inner loop invariant, header b18, val v251 = CMPBconst <flags> [126] v9, func ascompatee
cmd/compile/internal/gc/walk.go:1693: Inner loop invariant, header b2, val v373 = TESTQ <flags> v541 v541, func ascompatet
cmd/compile/internal/gc/walk.go:1925: Inner loop invariant, header b12, val v158 = SETEQ <bool> v603, func walkprint
cmd/compile/internal/gc/walk.go:1925: Inner loop invariant, header b12, val v603 = CMPBconst <flags> [91] v14, func walkprint
cmd/compile/internal/gc/walk.go:3617: Inner loop invariant, header b36, val v439 = ADDQconst <*Nodes> [32] v168, func walkprintfunc
cmd/compile/internal/gc/main.go:428: Inner loop invariant, header b2, val v57 = TESTB <flags> v7 v7, func Main.func1
cmd/compile/internal/arm
cmd/compile/internal/amd64
cmd/compile/internal/arm64
cmd/compile/internal/mips
# cmd/compile/internal/arm64
cmd/compile/internal/arm64/ggen.go:77: Inner loop invariant, header b7, val v36 = LEAQ1 <int64> [8] v11 v10, func zerorange
cmd/compile/internal/mips64
cmd/compile/internal/ppc64
# cmd/compile/internal/arm
cmd/compile/internal/arm/ggen.go:71: Inner loop invariant, header b20, val v191 = LEAQ1 <int64> [4] v12 v11, func zerorange
cmd/compile/internal/s390x
# cmd/compile/internal/amd64
cmd/compile/internal/amd64/ggen.go:135: Inner loop invariant, header b82, val v2175 = SARQconst <int64> [63] v382, func zerorange
cmd/compile/internal/amd64/ggen.go:135: Inner loop invariant, header b82, val v1035 = SHRQconst <int64> [60] v2175, func zerorange
cmd/compile/internal/amd64/ggen.go:135: Inner loop invariant, header b82, val v2185 = ADDQ <int64> v382 v1035, func zerorange
cmd/compile/internal/amd64/ggen.go:135: Inner loop invariant, header b82, val v809 = SARQconst <int64> [4] v2185, func zerorange
cmd/compile/internal/amd64/ggen.go:136: Inner loop invariant, header b82, val v813 = ADDQ <int64> v2445 v12, func zerorange
cmd/compile/internal/x86
# cmd/compile/internal/mips64
cmd/compile/internal/mips64/ggen.go:68: Inner loop invariant, header b7, val v36 = LEAQ1 <int64> [8] v11 v10, func zerorange
# cmd/compile/internal/ppc64
cmd/compile/internal/ppc64/prog.go:143: Inner loop invariant, header b12, val v62 = ANDLconst <int> [1023] v17, func initproginfo
cmd/compile/internal/ppc64/prog.go:143: Inner loop invariant, header b12, val v114 = CMPQconst <flags> [568] v62, func initproginfo
cmd/compile/internal/ppc64/prog.go:143: Inner loop invariant, header b12, val v64 = LEAQ8 <*[4]obj.As> v61 v62, func initproginfo
# cmd/compile/internal/x86
cmd/compile/internal/x86/ggen.go:71: Inner loop invariant, header b20, val v189 = ADDQ <int64> v12 v11, func zerorange
cmd/compile

@gopherbot
Copy link

@gopherbot gopherbot commented Feb 22, 2017

CL https://golang.org/cl/37338 mentions this issue.

@navytux
Copy link
Contributor

@navytux navytux commented Mar 25, 2017

For the reference - I was looking at encoding.hex.Encode() code becuase it shows high in my profiles and noticed: there is the same case presented originally in this issue:

TEXT ·Encode(SB), $8-56 // hex.go:29
...
pc39:
        MOVBLZX    (BX), DI         // hex.go:30
        MOVQ       SI, R8           // hex.go:31
        SHLQ       $1, SI
        MOVL       DI, R9
        SHRB       $4, DIB
        MOVBLZX    DIB, DI
        LEAQ       go.string."0123456789abcdef"(SB), R10 // hex.go:32           <-- NOTE
        MOVBLZX    (R10)(DI*1), DI  // hex.go:31
        CMPQ       SI, CX
        JCC        $0, pc139
        MOVB       DIB, (DX)(SI*1)
        LEAQ       1(SI), DI        // hex.go:32
        ANDL       $15, R9
        MOVBLZX    (R10)(R9*1), R9
        CMPQ       DI, CX
        JCC        $0, pc132
        MOVB       R9B, 1(DX)(SI*1)
        INCQ       BX               // hex.go:30
        LEAQ       1(R8), SI
        CMPQ       SI, AX
        JLT        $1, pc39

The LEAQ go.string."0123456789abcdef"(SB), R10 is loop invariant here, but

(citing from above)

encoding/hex
encoding/hex/hex.go:152: Inner loop invariant, header b2, val v68 = ADDQconst <*[14]byte> [34] v8, func (*dumper).Write
encoding/hex/hex.go:152: Inner loop invariant, header b2, val v78 = ADDQconst <*byte> [38] v8, func (*dumper).Write
encoding/hex/hex.go:160: Inner loop invariant, header b2, val v152 = ADDQconst <*[14]byte> [34] v8, func (*dumper).Write
encoding/hex/hex.go:179: Inner loop invariant, header b2, val v281 = ADDQconst <*[18]byte> [16] v8, func (*dumper).Write
encoding/hex/hex.go:213: Inner loop invariant, header b4, val v74 = ADDQconst <*[14]byte> [34] v6, func (*dumper).Close

the Encode() function is not reported for being detected with invariant in a loop.

Thanks,
Kirill

@josharian
Copy link
Contributor

@josharian josharian commented Mar 25, 2017

Out of curiosity, Kirill, is 1.8 any better than tip for Encode? (Or vice versa, depending on which you are using?) There was a recent change to CSE constant strings.

@navytux
Copy link
Contributor

@navytux navytux commented Mar 26, 2017

Josh, thanks for asking. I'm using tip by default. Tip is better than 1.8 for hex.Encode in that sense that 57370a8 (encoding/hex: change lookup table from string to array) is no longer needed because there is no longer two LEAQ go.string."0123456789abcdef"(SB) generated - only one is there left in a loop (probably that is due to CSE of constant strings you mention).

So the diff for assembly with the following patch applied

--- a/src/encoding/hex/hex.go
+++ b/src/encoding/hex/hex.go
@@ -12,10 +12,11 @@ import (
        "io"
 )
 
-var hextable = [16]byte{
-       '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
-       'a', 'b', 'c', 'd', 'e', 'f',
-}
+//var hextable = [16]byte{
+//     '0', '1', '2', '3', '4', '5', '6', '7', '8', '9',
+//     'a', 'b', 'c', 'd', 'e', 'f',
+//}
+const hextable = "0123456789abcdef"
 
 // EncodedLen returns the length of an encoding of n source bytes.
 // Specifically, it returns n * 2.

is only this:

--- a/0tip.sss
+++ b/0tipstr.sss
@@ -18,8 +18,8 @@ pc39:
        MOVL       DI, R9
        SHRB       $4, DIB
        MOVBLZX    DIB, DI
-       LEAQ       ·hextable(SB), R10
-       MOVBLZX    (R10)(DI*1), DI
+       LEAQ       go.string."0123456789abcdef"(SB), R10 // hex.go:32
+       MOVBLZX    (R10)(DI*1), DI  // hex.go:31
        CMPQ       SI, CX
        JCC        pc139
        MOVB       DIB, (DX)(SI*1)

(thus reverting 57370a8 would make sense anyway as then hextable will go to rodata and will be probably deduplicated by linker with other such tables /cc @ALTree, @bradfitz).

For present state - when hextable is [16]byte - assembly diff is:

--- a/018.sss
+++ b/0tip.sss
@@ -5,34 +5,34 @@ TEXT ·Encode(SB), $8-56 // hex.go:29
        // FUNCDATA $0, gclocals·b9de2a960cf046391bcd3b554f7fabca(SB) (args)
        FUNCDATA   $1, gclocals·69c1753bd5f81501d95132d08af04464(SB) (locals)
        MOVQ       src+32(FP), AX  // hex.go:30
+       TESTQ      AX, AX
+       JLE        pc115
        MOVQ       dst+8(FP), CX
        MOVQ       dst+0(FP), DX
        MOVQ       src+24(FP), BX
        MOVQ       $0, SI          // hex.go:29
-       CMPQ       SI, AX          // hex.go:30
-       JGE        $0, pc115
 pc39:
-       MOVBLZX    (BX), DI
-       MOVL       DI, R8          // hex.go:31
+       MOVBLZX    (BX), DI        // hex.go:30
+       MOVQ       SI, R8          // hex.go:31
+       SHLQ       $1, SI
+       MOVL       DI, R9
        SHRB       $4, DIB
        MOVBLZX    DIB, DI
-       LEAQ       ·hextable(SB), R9
-       MOVBLZX    (R9)(DI*1), DI
-       MOVQ       SI, R10
-       SHLQ       $1, SI
+       LEAQ       ·hextable(SB), R10
+       MOVBLZX    (R10)(DI*1), DI
        CMPQ       SI, CX
-       JCC        $0, pc139
+       JCC        pc139
        MOVB       DIB, (DX)(SI*1)
-       ANDL       $15, R8         // hex.go:32
-       MOVBLZX    (R9)(R8*1), DI
-       LEAQ       1(SI), R8
-       CMPQ       R8, CX
-       JCC        $0, pc132
-       MOVB       DIB, 1(DX)(SI*1)
+       LEAQ       1(SI), DI       // hex.go:32
+       ANDL       $15, R9
+       MOVBLZX    (R10)(R9*1), R9
+       CMPQ       DI, CX
+       JCC        pc132
+       MOVB       R9B, 1(DX)(SI*1)
        INCQ       BX              // hex.go:30
-       LEAQ       1(R10), SI
+       LEAQ       1(R8), SI
        CMPQ       SI, AX
-       JLT        $0, pc39
+       JLT        pc39
 pc115:
        SHLQ       $1, AX          // hex.go:35
        MOVQ       AX, _r2+48(FP)

which to me looks the same from the first glance modulo some different register allocations, reordering, and likely labels removed from jumps (@randall77 214be5b says likely hints are no longer needed "since #15837 was fixed" but #15837 is not yet fixed - maybe some thinko crept in?).

Thanks,
Kirill

@randall77
Copy link
Contributor Author

@randall77 randall77 commented Mar 26, 2017

#15837 is fixed in the sense that it matters here, and in 214be5b. The obj library no longer reorders instructions.
#15837 is only waiting for https://go-review.googlesource.com/c/38431/ before we close it.

@navytux
Copy link
Contributor

@navytux navytux commented Mar 26, 2017

@randall77 thanks for feedback and good luck with finding what is going on with regressions in that CL.

gopherbot pushed a commit that referenced this issue Apr 18, 2017
CL 27254 changed hextable to a byte array for performance.
CL 28219 fixed the compiler so that that is no longer necessary.
As Kirill notes in #15808, a string is preferable
as the linker can easily de-dup it.
So go back. No performance changes.

Change-Id: Ibef7d21d0f2507968a0606602c5dd57ed4a85b1b
Reviewed-on: https://go-review.googlesource.com/40970
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
Reviewed-by: Brad Fitzpatrick <bradfitz@golang.org>
TryBot-Result: Gobot Gobot <gobot@golang.org>
@gopherbot
Copy link

@gopherbot gopherbot commented Apr 21, 2017

CL https://golang.org/cl/40970 mentions this issue.

@bradfitz bradfitz modified the milestones: Go1.9Maybe, Go1.9Early May 3, 2017
@bradfitz
Copy link
Contributor

@bradfitz bradfitz commented May 3, 2017

@dr2chase, what's the status here?

@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented May 3, 2017

I have a CL up for looking at, there is some bad interaction with racewalk that I have yet to debug. It's unclear if it helps, it seems not to hurt, and there might be code not in our benchmarks that it helps. See https://go-review.googlesource.com/c/37338 -- I think it fails to mention this bug.

It may not help this particular bug, I'll try to check Thursday night or Friday.

@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented May 8, 2017

Status is now that TryBots are happy, but Go1 benchmarks contain no loop invariant code at all, so of course Revcomp slows down, but I think that is alignment-related.

@josharian
Copy link
Contributor

@josharian josharian commented May 18, 2017

@dr2chase over at #18977 (comment), @navytux hacked together a clever way to try out different alignments, so that luck (or lack thereof) can be assessed.

(Probably a coincidence, but @martisch was also puzzling over revcomp slowdowns in CL 38061.)

@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented May 19, 2017

From the CL: "Hoisting, but performance improvements are uninspiring."
I may give the alignment tweaking a look, but compared to other stuff in the pipeline I think this is less important.

More important:

  • deciding how to package debugging of optimized code (it slows compilation down by 50%, think anybody will mind?)
  • getting the loop rotation code right (I have a version of Keith's CL on top of yours that I am playing with, benchmarks are waiting for me upstairs).
@josharian
Copy link
Contributor

@josharian josharian commented May 19, 2017

compared to other stuff in the pipeline I think this is less important.

OK. I'll move this issue to 1.10, then. Feel free to move to Unplanned if you think that's better.

deciding how to package debugging of optimized code (it slows compilation down by 50%, think anybody will mind?)

:)

getting the loop rotation code right (I have a version of Keith's CL on top of yours that I am playing with, benchmarks are waiting for me upstairs).

Great!

By the way, do have any recommended reading for code layout? I don't know how much time I'll have in 1.10, but it seems like a promising and interesting area to pursue. (As usual, I have lots of ideas but not much background knowledge.)

@josharian josharian modified the milestones: Go1.10, Go1.9Maybe May 19, 2017
@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented May 19, 2017

Code layout? Everything I ever knew is obsolete now.
Rules of thumb I think we're supposed to follow:

  • super-rare stuff (panics, reschedule requests) ought to go at the end of the code
  • avoid branches (i.e., loop rotation good)
  • backedges ought to be backwards branches.
  • be sure (hot?) branch targets are at least in the first half of a cache line (?)
  • try to keep the code in the order it was written.

The difficult case is "what about code you think is less-executed that is in a loop?"
That could go in-line (respecting programmer order), after the loop (make the common code more compact), or at the end of the program. This assumes we believe our heuristics for "less-executed".

@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented Jun 26, 2018

I'm working with a somewhat larger number of benchmarks, and I'd normally expect movement in both directions that would tend to cancel out. If the benefit of the optimization is so small that I still see only tiny improvements (or worse, as in my most recent run, slowdowns), then it's not urgent, especially given the known costs of this optimization (a little more time to compile code, worsened debugging experience, greater exposure to bugs).

@laboger
Copy link
Contributor

@laboger laboger commented Jun 27, 2018

I did some investigation with your patch on ppc64le. On code inspection there were many loads I would expect to be moved out of the loop that were not. Perhaps there is just something to be tweaked to make this happen on ppc64le or maybe I don't understand what types of instructions are to be moved out by this patch.

In particular, I noticed the types of loads mentioned in issue #17110 were not being moved out. Those would provide a nice benefit for us.

@laboger
Copy link
Contributor

@laboger laboger commented Jul 10, 2018

Loop inside log.itoa with the latest CL with Go assembly and Power assembly:

 v21    00021 (81)      ADD     $-1, R4, R4
 v39    00022 (84)      ADD     $-1, R3, R3
 v81    00023 (80)      MOVD    R7, R5
 v89    00024 (80)      CMP     R5, $10
 b2     00025 (80)      BLT     39
 v70    00026 (82)      MOVD    $-3689348814741910323, R6
 v102   00027 (82)      MULHD   R5, R6, R7
 v104   00028 (82)      ADD     R5, R7, R7
 v107   00029 (82)      SRAD    $3, R7, R7
 v130   00030 (82)      SRAD    $63, R5, R8
 v23    00031 (82)      SUB     R8, R7, R7
 v25    00032 (83)      ADD     $48, R5, R5
 v73    00033 (83)      MOVD    $10, R8
 v26    00034 (83)      MULLD   R8, R7, R9
 v27    00035 (83)      SUB     R9, R5, R5
 v53    00036 (83)      CMPU    R3, $20
 b3     00037 (83)      BLT     15

   f1c44:       80 00 21 39     addi    r9,r1,128
   f1c48:       14 4a 43 7d     add     r10,r3,r9
   f1c4c:       00 00 aa 98     stb     r5,0(r10)
   f1c50:       ff ff 84 38     addi    r4,r4,-1
   f1c54:       ff ff 63 38     addi    r3,r3,-1
   f1c58:       78 3b e5 7c     mr      r5,r7
   f1c5c:       0a 00 25 2c     cmpdi   r5,10
   f1c60:       3c 00 80 41     blt     f1c9c <log.itoa+0x9c>
   f1c64:       16 00 e0 3f     lis     r31,22
   f1c68:       d0 4f df e8     ld      r6,20432(r31)
   f1c6c:       92 28 e6 7c     mulhd   r7,r6,r5
   f1c70:       14 2a e7 7c     add     r7,r7,r5
   f1c74:       74 1e e7 7c     sradi   r7,r7,3
   f1c78:       76 fe a8 7c     sradi   r8,r5,63
   f1c7c:       50 38 e8 7c     subf    r7,r8,r7
   f1c80:       30 00 a5 38     addi    r5,r5,48
   f1c84:       0a 00 00 39     li      r8,10
   f1c88:       d2 41 27 7d     mulld   r9,r7,r8
   f1c8c:       50 28 a9 7c     subf    r5,r9,r5
   f1c90:       14 00 23 28     cmpldi  r3,20
   f1c94:       b0 ff 80 41     blt     f1c44 <log.itoa+0x44>
@andybons andybons modified the milestones: Go1.12, Go1.13 Feb 12, 2019
@randall77 randall77 modified the milestones: Go1.13, Go1.14 Jun 3, 2019
@rsc rsc modified the milestones: Go1.14, Backlog Oct 9, 2019
@smasher164
Copy link
Member

@smasher164 smasher164 commented Dec 21, 2019

See #36196 for another general case where hoisting is needed. Intrinsics like population count, FMA and rounding that need to be guarded with feature detection incur additional overhead on each invocation, when it should really occur once outside the loop. This effect will be even more pronounced when we want to surface vectorization intrinsics for architectures without the support.

@gopherbot
Copy link

@gopherbot gopherbot commented Dec 21, 2019

Change https://golang.org/cl/212360 mentions this issue: cmd/compile: add intrinsic HasCPUFeature for checking cpu features

@josharian
Copy link
Contributor

@josharian josharian commented Dec 22, 2019

CL 212360 is one option for intrinsic guards, for discussion. For that to have maximum effect, we’d need an optimization that rewrote:

var b bool = ...
for ... {
  if b {
    ...
  } else {
    ...
  }
}

into

var b bool = ...
if b {
  for ... {
    ...
  }
} else {
  for ... {
    ... 
  }
}

Which is not always going to be an improvement. (Sorry about the sketchy code, on my phone.)

@smasher164
Copy link
Member

@smasher164 smasher164 commented Dec 27, 2019

For intrinsics like scalar FMA, round, etc..., the above optimization would really help. However, even if it is an improvement, that optimization scales linearly with the number of features. For an intrinsic that permits multiple tiers of conformance, i.e. SSE, AVX, etc... that could really inflate binary size. In this case, it may be worthwhile to dispatch the correct routine based on a function-pointer set up on init, like GCC's function multi-versioning.

@laboger
Copy link
Contributor

@laboger laboger commented Mar 4, 2020

Here are some examples from ppc64le where the constants are not hoisted out of loops, using https://go-review.googlesource.com/c/go/+/37338

This is a snippet from indexRabinKarp which is used quite a bit in bytes and strings. I usually build the test under the bytes package and then do an objdump of that.

  0xc1fb4               39480001                ADD R8,$1,R10           
                h = h*primeRK + uint32(s[i])
  0xc1fb8               640b0100                ORIS R0,$256,R11       <-- constant (takes 2 instructions)
  0xc1fbc               616b0193                ORI R11,$403,R11
  0xc1fc0               7d8959d6                MULLW R9,R11,R12        
  0xc1fc4               7dc828ae                MOVBZ (R5)(R8),R14      
  0xc1fc8               7d2e6214                ADD R14,R12,R9          
        for i := 0; i < n; i++ {
  0xc1fcc               7d485378                OR R10,R10,R8           
  0xc1fd0               7c283800                CMP R8,R7               
  0xc1fd4               40800010                BGE 0xc1fe4             
                h = h*primeRK + uint32(s[i])
  0xc1fd8               7c283040                CMPU R8,R6              
  0xc1fdc               4180ffd8                BLT 0xc1fb4             

I'm also not sure what is being doing with R8 and R10, it should be able to just add 1 to R8 after its use and avoid the extra move, but that is a different problem.

I've mainly looked at constants not being hoisted because I'm not sure when variables are considered invariant in Go. I'm familiar with aliasing rules in C and Fortran but I don't know what they are for Go (although I haven't looked real hard either).

I can certainly help on this with testing or trying out changes. Just let me know.

Another example from test/bench/go1 the first loop in mandelbrot().

@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented Mar 4, 2020

If constants would help, we can do that. One problem is that they are marked as rematerializable to the register allocator, which tends to put them back into the loop closer to their uses. I had to deal with this very problem testing whether an idiom for absolute value could be improved on Intel (do it all in the FP registers, use PAND 0x7fffetc to clear the sign bit). Not sure if we need to change the register allocator's heuristics a bit, or just be more careful about which constants are rematerializable.

@josharian
Copy link
Contributor

@josharian josharian commented Mar 4, 2020

Whatever we do here, it’d be good to try to keep tighten working hand in glove with regalloc. (Cf https://go-review.googlesource.com/c/go/+/177041)

@laboger
Copy link
Contributor

@laboger laboger commented Mar 4, 2020

Ha, well I guess I was misled by the title of this issue and didn't read the rest very thoroughly.

Maybe I can hack it so constants can be hoisted for ppc64le and see how much it helps. And I will turn on some traces to understand what is being hoisted.

gopherbot pushed a commit that referenced this issue Apr 4, 2020
Before using some CPU instructions, we must check for their presence.
We use global variables in the runtime package to record features.

Prior to this CL, we issued a regular memory load for these features.
The downside to this is that, because it is a regular memory load,
it cannot be hoisted out of loops or otherwise reordered with other loads.

This CL introduces a new intrinsic just for checking cpu features.
It still ends up resulting in a memory load, but that memory load can
now be floated to the entry block and rematerialized as needed.

One downside is that the regular load could be combined with the comparison
into a CMPBconstload+NE. This new intrinsic cannot; it generates MOVB+TESTB+NE.
(It is possible that MOVBQZX+TESTQ+NE would be better.)

This CL does only amd64. It is easy to extend to other architectures.

For the benchmark in #36196, on my machine, this offers a mild speedup.

name      old time/op  new time/op  delta
FMA-8     1.39ns ± 6%  1.29ns ± 9%  -7.19%  (p=0.000 n=97+96)
NonFMA-8  2.03ns ±11%  2.04ns ±12%    ~     (p=0.618 n=99+98)

Updates #15808
Updates #36196

Change-Id: I75e2fcfcf5a6df1bdb80657a7143bed69fca6deb
Reviewed-on: https://go-review.googlesource.com/c/go/+/212360
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
Reviewed-by: Giovanni Bajo <rasky@develer.com>
@gopherbot
Copy link

@gopherbot gopherbot commented Apr 5, 2020

Change https://golang.org/cl/227238 mentions this issue: cmd/compile: use MOVBQZX for OpAMD64LoweredHasCPUFeature

gopherbot pushed a commit that referenced this issue Apr 7, 2020
In the commit message of CL 212360, I wrote:

> This new intrinsic ... generates MOVB+TESTB+NE.
> (It is possible that MOVBQZX+TESTQ+NE would be better.)

I should have tested. MOVBQZX+TESTQ+NE does in fact appear to be better.

For the benchmark in #36196, on my machine:

name      old time/op  new time/op  delta
FMA-8     0.86ns ± 6%  0.70ns ± 5%  -18.79%  (p=0.000 n=98+97)
NonFMA-8  0.61ns ± 5%  0.60ns ± 4%   -0.74%  (p=0.001 n=100+97)

Interestingly, these are both considerably faster than
the measurements I took a couple of months ago (1.4ns/2ns).
It appears that CL 219131 (clearing VZEROUPPER in asyncPreempt) helped a lot.
And FMA is now once again slower than NonFMA, although this change
helps it regain some ground.

Updates #15808
Updates #36351
Updates #36196

Change-Id: I8a326289a963b1939aaa7eaa2fab2ec536467c7d
Reviewed-on: https://go-review.googlesource.com/c/go/+/227238
Run-TryBot: Josh Bleecher Snyder <josharian@gmail.com>
TryBot-Result: Gobot Gobot <gobot@golang.org>
Reviewed-by: Keith Randall <khr@golang.org>
@laboger
Copy link
Contributor

@laboger laboger commented Jun 29, 2020

I have time now to look at this again. I was not able to successfully disable tighten in order get constants moved out. I understand the purpose of doing the tighten but seems like there should be allowance for loops where loads can be moved to the dominator block of a loop? Maybe only for some targets like ppc64 and arm64 where there are more registers and loads cost more.

Another question I had is whether NilCheck should/could be moved out of a loop if the pointer or address it is checking is invariant? Seems like doing it once before the loop should be sufficient.

@randall77
Copy link
Contributor Author

@randall77 randall77 commented Jun 29, 2020

The tighten pass will only move values toward their uses, it will not move values back.
It already has a rule to avoid moving values into loops. It will not move values out of loops, though.

Moving loads and nil checks around is tricky, because we need panics to appear at the correct place. For instance, if a loop runs 0 times, we can't lift a nil check out of the loop. Loads that we know won't fault could be lifted, though. I think David's CL did something like that.

I'd like to see something on this front, though. There are certainly things that are safe to lift out of loops that would help.

@laboger
Copy link
Contributor

@laboger laboger commented Jun 29, 2020

If constants would help, we can do that. One problem is that they are marked as rematerializable to the register allocator, which tends to put them back into the loop closer to their uses. I had to deal with this very problem testing whether an idiom for absolute value could be improved on Intel (do it all in the FP registers, use PAND 0x7fffetc to clear the sign bit). Not sure if we need to change the register allocator's heuristics a bit, or just be more careful about which constants are rematerializable.

Yes I think it would be good to hoist constants. In the other compilers for ppc64, the base address of an array is moved back before the loop, but in Go the address is always loaded and the array element address computed each time in the loop. I tried changing regalloc to get the constants hoisted but couldn't get it to work, so based on what Josh said earlier I assumed that one of the tighten passes was preventing it.

Moving loads and nil checks around is tricky, because we need panics to appear at the correct place. For instance, if a loop runs 0 times, we can't lift a nil check out of the loop. Loads that we know won't fault could be lifted, though. I think David's CL did something like that.

Agreed, and if you can tell if the loop executes at least once then it should be possible to do this.

Not sure if we need to change the register allocator's heuristics a bit, or just be more careful about which constants are rematerializable.

I think it is good to leave constants as rematerializable to avoid extra code to spill the value, but just should be treated differently with respect to hoisting.

@laboger
Copy link
Contributor

@laboger laboger commented Jul 24, 2020

@dr2chase I don't see how loads of constants could be hoisted with your CL. It is only saving v's from the block as candidates to be hoisted, not any of their args or any subexpressions for that matter.

@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented Jul 24, 2020

I think that
https://go-review.googlesource.com/c/go/+/37338/16/src/cmd/compile/internal/ssa/loopinvariants.go
between lines 84-96, it adds invariant args of whatever is in the filtered invariant set to that set
and lines 108-125, everything in the filtered invariant set is moved into the loop's parent block.

One problem we have is that constant-loads that take a mem operand, in a loop where there are stores or calls,
will become not-invariant because of the mem operand, even though they are in fact constant. But we have PPC64MOVDconst, and that's not called out as variant and it doesn't take a mem, so I think that should work.

I'm a little bugged that critical edges is not run before early hoistloopiv; the code at lines 60-66 assumes that implicitly (it assumes that there is a unique parent).

@laboger
Copy link
Contributor

@laboger laboger commented Jul 24, 2020

The filtered invariant set is based on what's returned from the loopinvariants function, which only returns v's that are invariant. So in one case I'm looking at is in package log function itoa where there is a multiply of a constant with a variable and I want the constant to be moved out. The multiply is not invariant so isn't in the filtered invariant set, which means the constant arg is not processed in the lines you mentioned above.

@dr2chase
Copy link
Contributor

@dr2chase dr2chase commented Jul 24, 2020

But, in the late hoist, isn't the constant arg visible as a load of a constant, hence invariant?
Or is it still only present as an AuxInt?

@laboger
Copy link
Contributor

@laboger laboger commented Jul 24, 2020

I added a few extra prints to the debug output like this:

                       for _, a := range v.Args {
                                if b.Func.pass.debug > 2 && v.Op != OpPhi {
                                        fmt.Printf("Checking a: %s contains: %v\n", a.LongString(), ss.contains(a.ID))
                                }

                                bb := a.Block
                                if b2l[bb.ID] == l && !ss.contains(a.ID) {
                                        if b.Func.pass.debug > 2 && v.Op != OpPhi {
                                                fmt.Printf("Skipping a: %s\n", a.LongString())
                                        }
                                        continue valloop
                                }
                                s := cost + int((*m)[a])
                                if s > 255 {
                                        s = 255
                                }
                                cost = s
                        }
                        // all args for v originate elsewhere or are loop invariant
                        if !ss.contains(v.ID) {
                                change = true
                                ss.add(v.ID)
                                if b.Func.pass.debug > 2 {
                                        fmt.Printf("Adding v: %s to ss\n", v.LongString())
                                }
                                (*m)[v] = uint8(cost)
                        }

which results in this:

Initial checking of v: v82 = MULHD <int> v120 v14
Checking v: v82 = MULHD <int> v120 v14
Checking a: v120 = MOVDconst <uint64> [-3689348814741910323] contains: false
Checking a: v14 = Phi <int> v8 v25 (i[int]) contains: false
Skipping a: v14 = Phi <int> v8 v25 (i[int])

So the MOVDconst has the constant value in its auxint. But as I read the code, the Phi is not already in ss so it takes the continue path and doesn't add the MULHD to the list.

Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment
Projects
None yet
Linked pull requests

Successfully merging a pull request may close this issue.

None yet
You can’t perform that action at this time.