Stowage/go
2
0
Fork 0
mirror of https://github.com/golang/go.git synced 2025-12-08 06:10:04 +00:00
Code Issues Projects Releases Packages Wiki Activity

[dev.simd] all: merge master (57362e9) into dev.simd

Browse source 
Conflicts:

- src/cmd/compile/internal/ir/symtab.go
- src/cmd/compile/internal/ssa/prove.go
- src/cmd/compile/internal/ssa/rewriteAMD64.go
- src/cmd/compile/internal/ssagen/intrinsics.go
- src/cmd/compile/internal/typecheck/builtin.go
- src/internal/buildcfg/exp.go
- src/internal/strconv/ftoa.go
- test/codegen/stack.go

Manually resolved some conflicts:

- Use internal/strconv for simd.String, remove internal/ftoa
- prove.go is just copied from the one on the main branch. We
  have cherry-picked the changes to prove.go to main branch, so
  our copy is identical to an old version of the one on the main
  branch. There are CLs landed after our cherry-picks. Just copy
  it over to adopt the new code.

Merge List:

+ 2025-11-13 57362e9814 go/types, types2: check for direct cycles as a separate phase
+ 2025-11-13 099e0027bd cmd/go/internal/modfetch: consolidate global vars
+ 2025-11-13 028375323f cmd/go/internal/modfetch/codehost: fix flaky TestReadZip
+ 2025-11-13 4ebf295b0b runtime: prefer to restart Ps on the same M after STW
+ 2025-11-13 625d8e9b9c runtime/pprof: fix goroutine leak profile tests for noopt
+ 2025-11-13 4684a26c26 spec: remove cycle restriction for type parameters
+ 2025-11-13 0f9c8fb29d cmd/asm,cmd/internal/obj/riscv: add support for riscv compressed instructions
+ 2025-11-13 a15d036ce2 cmd/internal/obj/riscv: implement better bit pattern encoding
+ 2025-11-12 abb241a789 cmd/internal/obj/loong64: add {,X}VS{ADD,SUB}.{B/H/W/V}{,U} instructions support
+ 2025-11-12 0929d21978 cmd/go: keep objects alive while stopping cleanups
+ 2025-11-12 f03d06ec1a runtime: fix list test memory management for mayMoreStack
+ 2025-11-12 48127f656b crypto/internal/fips140/sha3: remove outdated TODO
+ 2025-11-12 c3d1d42764 sync/atomic: amend comments for Value.{Swap,CompareAndSwap}
+ 2025-11-12 e0807ba470 cmd/compile: don't clear ptrmask in fillptrmask
+ 2025-11-12 66318d2b4b internal/abi: correctly describe result in Name.Name doc comment
+ 2025-11-12 34aef89366 cmd/compile: use FCLASSD for subnormal checks on riscv64
+ 2025-11-12 0c28789bd7 net/url: disallow raw IPv6 addresses in host
+ 2025-11-12 4e761b9a18 cmd/compile: optimize liveness in stackalloc
+ 2025-11-12 956909ff84 crypto/x509: move BetterTLS suite from crypto/tls
+ 2025-11-12 6525f46707 cmd/link: change shdr and phdr from arrays to slices
+ 2025-11-12 d3aeba1670 runtime: switch p.gcFractionalMarkTime to atomic.Int64
+ 2025-11-12 8873e8bea2 runtime,runtime/pprof: clean up goroutine leak profile writing
+ 2025-11-12 b8b84b789e cmd/go: clarify the -o testflag is only for copying the binary
+ 2025-11-12 c761b26b56 mime: parse media types that contain braces
+ 2025-11-12 65858a146e os/exec: include Cmd.Start in the list of methods that run Cmd
+ 2025-11-11 4bfc3a9d14 std,cmd: go fix -any std cmd
+ 2025-11-11 2263d4aabd runtime: doubly-linked sched.midle list
+ 2025-11-11 046dce0e54 runtime: use new list type for spanSPMCs
+ 2025-11-11 5f11275457 runtime: reusable intrusive doubly-linked list
+ 2025-11-11 951cf0501b internal/trace/testtrace: fix flag name typos
+ 2025-11-11 2750f95291 cmd/go: implement accurate pseudo-versions for Mercurial
+ 2025-11-11 b709a3e8b4 cmd/go/internal/vcweb: cache hg servers
+ 2025-11-11 426ef30ecf cmd/go: implement -reuse for Mercurial repos
+ 2025-11-10 5241d114f5 spec: more precise prose for special case of append
+ 2025-11-10 cdf64106f6 go/types, types2: first argument to append must never be be nil
+ 2025-11-10 a0eb4548cf .gitignore: ignore go test artifacts
+ 2025-11-10 bf58e7845e internal/trace: add "command" to convert text traces to raw
+ 2025-11-10 052c192a4c runtime: fix lock rank for work.spanSPMCs.lock
+ 2025-11-10 bc5ffe5c79 internal/runtime/sys,math/bits: eliminate bounds checks on len8tab
+ 2025-11-10 32f8d6486f runtime: document that tracefpunwindoff applies to some profilers
+ 2025-11-10 1c1c1942ba cmd/go: remove redundant AVX regex in security flag checks
+ 2025-11-10 3b3d6b9e5d cmd/internal/obj/arm64: shorten constant integer loads
+ 2025-11-10 5f4b5f1a19 runtime/msan: use different msan routine for copying
+ 2025-11-10 0fe6c8e8c8 runtime: tweak wording for comment of mcache.flushGen
+ 2025-11-10 95a0e5adc1 sync: don't call Done when f() panics in WaitGroup.Go
+ 2025-11-08 e8ed85d6c2 cmd/go: update goSum if necessary
+ 2025-11-08 b76103c08e cmd/go: output missing GoDebug entries
+ 2025-11-07 47a63a331d cmd/go: rewrite hgrepo1 test repo to be deterministic
+ 2025-11-07 7995751d3a cmd/go: copy git reuse and support repos to hg
+ 2025-11-07 66c7ca7fb3 cmd/go: improve TestScript/reuse_git
+ 2025-11-07 de84ac55c6 cmd/link: clean up some comments to Go standards
+ 2025-11-07 5cd1b73772 runtime: correctly print panics before fatal-ing on defer
+ 2025-11-07 91ca80f970 runtime/cgo: improve error messages after pointer panic
+ 2025-11-07 d36e88f21f runtime: tweak wording for doc
+ 2025-11-06 ad3ccd92e4 cmd/link: move pclntab out of relro section
+ 2025-11-06 43b91e7abd iter: fix a tiny doc comment bug
+ 2025-11-06 48c7fa13c6 Revert "runtime: remove the pc field of _defer struct"
+ 2025-11-05 8111104a21 cmd/internal/obj/loong64: add {,X}VSHUF.{B/H/W/V} instructions support
+ 2025-11-05 2e2072561c cmd/internal/obj/loong64: add {,X}VEXTRINS.{B,H,W,V} instruction support
+ 2025-11-05 01c29d1f0b internal/chacha8rand: replace VORV with instruction VMOVQ on loong64
+ 2025-11-05 f01a1841fd cmd/compile: fix error message on loong64
+ 2025-11-05 8cf7a0b4c9 cmd/link: support weak binding on darwin
+ 2025-11-05 2dd7e94e16 cmd/go: use go.dev instead of golang.org in flag errors
+ 2025-11-05 28f1ad5782 cmd/go: fix TestScript/govcs
+ 2025-11-05 daa220a1c9 cmd/go: silence TLS handshake errors during test
+ 2025-11-05 3ae9e95002 cmd/go: fix TestCgoPkgConfig on darwin with pkg-config installed
+ 2025-11-05 a494a26bc2 cmd/go: fix TestScript/vet_flags
+ 2025-11-05 a8fb94969c cmd/go: fix TestScript/tool_build_as_needed
+ 2025-11-05 04f05219c4 cmd/cgo: skip escape checks if call site has no argument
+ 2025-11-04 9f3a108ee0 os: ignore O_TRUNC errors on named pipes and terminal devices on Windows
+ 2025-11-04 0e1bd8b5f1 cmd/link, runtime: don't store text start in pcHeader
+ 2025-11-04 7347b54727 cmd/link: don't generate .gosymtab section
+ 2025-11-04 6914dd11c0 cmd/link: add and use new SymKind SFirstUnallocated
+ 2025-11-04 f5f14262d0 cmd/link: remove misleading comment
+ 2025-11-04 61de3a9dae cmd/link: remove unused SFILEPATH symbol kind
+ 2025-11-04 8e2bd267b5 cmd/link: add comments for SymKind values
+ 2025-11-04 16705b962e cmd/compile: faster liveness analysis in regalloc
+ 2025-11-04 a5fe6791d7 internal/syscall/windows: fix ReOpenFile sentinel error value
+ 2025-11-04 a7d174ccaa cmd/compile/internal/ssa: simplify riscv64 FCLASSD rewrite rules
+ 2025-11-04 856238615d runtime: amend doc for setPinned
+ 2025-11-04 c7ccbddf22 cmd/compile/internal/ssa: more aggressive on dead auto elim
+ 2025-11-04 75b2bb1d1a cmd/cgo: drop pre-1.18 support
+ 2025-11-04 dd839f1d00 internal/strconv: handle %f with fixedFtoa when possible
+ 2025-11-04 6e165b4d17 cmd/compile: implement Avg64u, Hmul64, Hmul64u for wasm
+ 2025-11-04 9f6590f333 encoding/pem: don't reslice in failure modes
+ 2025-11-03 34fec512ce internal/strconv: extract fixed-precision ftoa from ftoaryu.go
+ 2025-11-03 162ba6cc40 internal/strconv: add tests and benchmarks for ftoaFixed
+ 2025-11-03 9795c7ba22 internal/strconv: fix pow10 off-by-one in exponent result
+ 2025-11-03 ad5e941a45 cmd/internal/obj/loong64: using {xv,v}slli.d to perform copying between vector registers
+ 2025-11-03 dadbac0c9e cmd/internal/obj/loong64: add VPERMI.W, XVPERMI.{W,V,Q} instruction support
+ 2025-11-03 e2c6a2024c runtime: avoid append in printint, printuint
+ 2025-11-03 c93cc603cd runtime: allow Stack to traceback goroutines in syscall _Grunning window
+ 2025-11-03 b5353fd90a runtime: don't panic in castogscanstatus
+ 2025-11-03 43491f8d52 cmd/cgo: use the export'ed file/line in error messages
+ 2025-11-03 aa94fdf0cc cmd/go: link to go.dev/doc/godebug for removed GODEBUG settings
+ 2025-11-03 4d2b03d2fc crypto/tls: add BetterTLS test coverage
+ 2025-11-03 0c4444e13d cmd/internal/obj: support arm64 FMOVQ large offset encoding
+ 2025-11-03 85bec791a0 cmd/go/testdata/script: loosen list_empty_importpath for freebsd
+ 2025-11-03 17b57078ab internal/runtime/cgobench: add cgo callback benchmark
+ 2025-11-03 5f8fdb720c cmd/go: move functions to methods
+ 2025-11-03 0a95856b95 cmd/go: eliminate additional global variable
+ 2025-11-03 f93186fb44 cmd/go/internal/telemetrystats: count cgo usage
+ 2025-11-03 eaf28a27fd runtime: update outdated comments for deferprocStack
+ 2025-11-03 e12d8a90bf all: remove extra space in the comments
+ 2025-11-03 c5559344ac internal/profile: optimize Parse allocs
+ 2025-11-03 5132158ac2 bytes: add Buffer.Peek
+ 2025-11-03 361d51a6b5 runtime: remove the pc field of _defer struct
+ 2025-11-03 00ee1860ce crypto/internal/constanttime: expose intrinsics to the FIPS 140-3 packages
+ 2025-11-02 388c41c412 cmd/go: skip git sha256 tests if git < 2.29
+ 2025-11-01 385dc33250 runtime: prevent time.Timer.Reset(0) from deadlocking testing/synctest tests
+ 2025-10-31 99b724f454 cmd/go: document purego convention
+ 2025-10-31 27937289dc runtime: avoid zeroing scavenged memory
+ 2025-10-30 89dee70484 runtime: prioritize panic output over racefini
+ 2025-10-30 8683bb846d runtime: optimistically CAS atomicstatus directly in enter/exitsyscall
+ 2025-10-30 5b8e850340 runtime: don't track scheduling latency for _Grunning <-> _Gsyscall
+ 2025-10-30 251814e580 runtime: document tracer invariants explicitly
+ 2025-10-30 7244e9221f runtime: eliminate _Psyscall
+ 2025-10-30 5ef19c0d0c strconv: delete divmod1e9
+ 2025-10-30 d32b1f02c3 runtime: delete timediv
+ 2025-10-30 cbbd385cb8 strconv: remove arch-specific decision in formatBase10
+ 2025-10-30 6aca04a73a reflect: correct internal docs for uncommonType
+ 2025-10-30 235b4e729d cmd/compile/internal/ssa: model right shift more precisely
+ 2025-10-30 d44db293f9 go/token: fix a typo in a comment
+ 2025-10-30 cdc6b559ca strconv: remove hand-written divide on 32-bit systems
+ 2025-10-30 1e5bb416d8 cmd/compile: implement bits.Mul64 on 32-bit systems
+ 2025-10-30 38317c44e7 crypto/internal/fips140/aes: fix CTR generator
+ 2025-10-29 3be9a0e014 go/types, types: proceed with correct (invalid) type in case of a selector error
+ 2025-10-29 d2c5fa0814 strconv: remove &0xFF trick in formatBase10
+ 2025-10-29 9bbda7c99d cmd/compile: make prove understand div, mod better
+ 2025-10-29 915c1839fe test/codegen: simplify asmcheck pattern matching
+ 2025-10-29 32ee3f3f73 runtime: tweak example code for gorecover
+ 2025-10-29 da3fb90b23 crypto/internal/fips140/bigmod: fix extendedGCD comment
+ 2025-10-29 9035f7aea5 runtime: use internal/strconv
+ 2025-10-29 49c1da474d internal/itoa, internal/runtime/strconv: delete
+ 2025-10-29 b2a346bbd1 strconv: move all but Quote to internal/strconv
+ 2025-10-28 041f564b3e internal/runtime/gc/scan: avoid memory destination on VPCOMPRESSQ
+ 2025-10-28 81afd3a59b cmd/compile: extend ppc64 MADDLD to match const ADDconst & MULLDconst
+ 2025-10-28 ea50d61b66 cmd/compile: name change isDirect -> isDirectAndComparable
+ 2025-10-28 bd4dc413cd cmd/compile: don't optimize away a panicing interface comparison
+ 2025-10-28 30c047d0d0 cmd/compile: extend loong MOV*idx rules to match ADDshiftLLV
+ 2025-10-28 46e5e2b09a runtime: define PanicBounds in funcdata.h
+ 2025-10-28 3da0356685 crypto/internal/fips140test: collect 300M entropy samples for ESV
+ 2025-10-28 d5953185d5 runtime: amend comments a bit
+ 2025-10-28 12c8d14d94 errors: document that the target of Is must be comparable
+ 2025-10-28 1f4d14e493 go/types, types2: pull up package-level object sort to a separate phase
+ 2025-10-28 b8aa1ee442 go/types, types2: reduce locks held at once in resolveUnderlying
+ 2025-10-28 24af441437 cmd/compile: rewrite proved multiplies by 0 or 1 into CondSelect
+ 2025-10-28 2d33a456c6 cmd/compile: move branchelim supported arches to Config
+ 2025-10-27 2c91c33e88 crypto/subtle,cmd/compile: add intrinsics for ConstantTimeSelect and *Eq
+ 2025-10-27 73d7635fae cmd/compile: add generic rules to remove bool → int → bool roundtrips
+ 2025-10-27 1662d55247 cmd/compile: do not Zext bools to 64bits in amd64 CMOV generation rules
+ 2025-10-27 b8468d8c4e cmd/compile: introduce bytesizeToConst to cleanup switches in prove
+ 2025-10-27 9e25c2f6de cmd/link: internal linking support for windows/arm64
+ 2025-10-27 ff2ebf69c4 internal/runtime/gc/scan: correct size class size check
+ 2025-10-27 9a77aa4f08 cmd/compile: add position info to sccp debug messages
+ 2025-10-27 77dc138030 cmd/compile: teach prove about unsigned rounding-up divide
+ 2025-10-27 a0f33b2887 cmd/compile: change !l.nonzero() into l.maybezero()
+ 2025-10-27 5453b788fd cmd/compile: optimize Add64carry with unused carries into plain Add64
+ 2025-10-27 2ce5aab79e cmd/compile: remove 68857 ModU flowLimit workaround in prove
+ 2025-10-27 a50de4bda7 cmd/compile: remove 68857 min & max flowLimit workaround in prove
+ 2025-10-27 53be78630a cmd/compile: use topo-sort in prove to correctly learn facts while walking once
+ 2025-10-27 dec2b4c83d runtime: avoid bound check in freebsd binuptime
+ 2025-10-27 916e682d51 cmd/internal/obj, cmd/asm: reclassify the offset of memory access operations on loong64
+ 2025-10-27 2835b994fb cmd/go: remove global loader state variable
+ 2025-10-27 139f89226f cmd/go: use local state for telemetry
+ 2025-10-27 8239156571 cmd/go: use tagged switch
+ 2025-10-27 d741483a1f cmd/go: increase stmt threshold on amd64
+ 2025-10-27 a6929cf4a7 cmd/go: removed unused code in toolchain.Exec
+ 2025-10-27 180c07e2c1 go/types, types2: clarify docs for resolveUnderlying
+ 2025-10-27 d8a32f3d4b go/types, types2: wrap Named.fromRHS into Named.rhs
+ 2025-10-27 b2af92270f go/types, types2: verify stateMask transitions in debug mode
+ 2025-10-27 92decdcbaa net/url: further speed up escape and unescape
+ 2025-10-27 5f4ec3541f runtime: remove unused cgoCheckUsingType function
+ 2025-10-27 189f2c08cc time: rewrite IsZero method to use wall and ext fields
+ 2025-10-27 f619b4a00d cmd/go: reorder parameters so that context is first
+ 2025-10-27 f527994c61 sync: update comments for Once.done
+ 2025-10-26 5dcaf9a01b runtime: add GOEXPERIMENT=runtimefree
+ 2025-10-26 d7a52f9369 cmd/compile: use MOV(D|F) with const for Const(64|32)F on riscv64
+ 2025-10-26 6f04a92be3 internal/chacha8rand: provide vector implementation for riscv64
+ 2025-10-26 54e3adc533 cmd/go: use local loader state in test
+ 2025-10-26 ca379b1c56 cmd/go: remove loaderstate dependency
+ 2025-10-26 83a44bde64 cmd/go: remove unused loader state
+ 2025-10-26 7e7cd9de68 cmd/go: remove temporary rf cleanup script
+ 2025-10-26 53ad68de4b cmd/compile: allow unaligned load/store on Wasm
+ 2025-10-25 12ec09f434 cmd/go: use local state object in work.runBuild and work.runInstall
+ 2025-10-24 643f80a11f runtime: add ppc and s390 to 32 build constraints for gccgo
+ 2025-10-24 0afbeb5102 runtime: add ppc and s390 to linux 32 bits syscall build constraints for gccgo
+ 2025-10-24 7b506d106f cmd/go: use local state object in `generate.runGenerate`
+ 2025-10-24 26a8a21d7f cmd/go: use local state object in `env.runEnv`
+ 2025-10-24 f2dd3d7e31 cmd/go: use local state object in `vet.runVet`
+ 2025-10-24 784700439a cmd/go: use local state object in pkg `workcmd`
+ 2025-10-24 69673e9be2 cmd/go: use local state object in `tool.runTool`
+ 2025-10-24 2e12c5db11 cmd/go: use local state object in `test.runTest`
+ 2025-10-24 fe345ff2ae cmd/go: use local state object in `modget.runGet`
+ 2025-10-24 d312e27e8b cmd/go: use local state object in pkg `modcmd`
+ 2025-10-24 ea9cf26aa1 cmd/go: use local state object in `list.runList`
+ 2025-10-24 9926e1124e cmd/go: use local state object in `bug.runBug`
+ 2025-10-24 2c4fd7b2cd cmd/go: use local state object in `run.runRun`
+ 2025-10-24 ade9f33e1f cmd/go: add loaderstate as field on `mvsReqs`
+ 2025-10-24 ccf4192a31 cmd/go: make ImportMissingError work with local state
+ 2025-10-24 f5403f15f0 debug/pe: check for zdebug_gdb_scripts section in testDWARF
+ 2025-10-24 a26f860fa4 runtime: use 32-bit hash for maps on Wasm
+ 2025-10-24 747fe2efed encoding/json/v2: fix typo in documentation about errors.AsType
+ 2025-10-24 94f47fc03f cmd/link: remove pointless assignment in SetSymAlign
+ 2025-10-24 e6cff69051 crypto/x509: move constraint checking after chain building
+ 2025-10-24 f5f69a3de9 encoding/json/jsontext: avoid pinning application data in pools
+ 2025-10-24 a6a59f0762 encoding/json/v2: use slices.Sort directly
+ 2025-10-24 0d3dab9b1d crypto/x509: simplify candidate chain filtering
+ 2025-10-24 29046398bb cmd/go: refactor injection of modload.LoaderState
+ 2025-10-24 c18fa69e52 cmd/go: make ErrNoModRoot work with local state
+ 2025-10-24 296ecc918d cmd/go: add modload.State parameter to AllowedFunc
+ 2025-10-24 c445a61e52 cmd/go: add loaderstate as field on `QueryMatchesMainModulesError`
+ 2025-10-24 6ac40051d3 cmd/go: remove module loader state from ccompile
+ 2025-10-24 6a5a452528 cmd/go: inject vendor dir into builder struct
+ 2025-10-23 dfac972233 crypto/pbkdf2: add missing error return value in example
+ 2025-10-23 47bf8f073e unique: fix inconsistent panic prefix in canonmap cleanup path
+ 2025-10-23 03bd43e8bb go/types, types2: rename Named.resolve to unpack
+ 2025-10-23 9fcdc814b2 go/types, types2: rename loaded namedState to lazyLoaded
+ 2025-10-23 8401512a9b go/types, types2: rename complete namedState to hasMethods
+ 2025-10-23 cf826bfcb4 go/types, types2: set t.underlying exactly once in resolveUnderlying
+ 2025-10-23 c4e910895b net/url: speed up escape and unescape
+ 2025-10-23 3f6ac3a10f go/build: use slices.Equal
+ 2025-10-23 839da71f89 encoding/pem: properly calculate end indexes
+ 2025-10-23 39ed968832 cmd: update golang.org/x/arch for riscv64 disassembler
+ 2025-10-23 ca448191c9 all: replace Split in loops with more efficient SplitSeq
+ 2025-10-23 107fcb70de internal/goroot: replace HasPrefix+TrimPrefix with CutPrefix
+ 2025-10-23 8378276d66 strconv: optimize int-to-decimal and use consistently
+ 2025-10-23 e5688d0bdd cmd/internal/obj/riscv: simplify validation and encoding of raw instructions
+ 2025-10-22 77fc27972a doc/next: improve new(expr) release note
+ 2025-10-22 d94a8c56ad runtime: cleanup pagetrace
+ 2025-10-22 02728a2846 crypto/internal/fips140test: add entropy SHA2-384 testing
+ 2025-10-22 f92e01c117 runtime/cgo: fix cgoCheckArg description
+ 2025-10-22 50586182ab runtime: use backoff and ISB instruction to reduce contention in (*lfstack).pop and (*spanSet).pop on arm64
+ 2025-10-22 1ff59f3dd3 strconv: clean up powers-of-10 table, tests
+ 2025-10-22 7c9fa4d5e9 cmd/go: check if build output should overwrite files with renames
+ 2025-10-22 557b4d6e0f comment: change slice to string in function comment/help
+ 2025-10-22 d09a8c8ef4 go/types, types2: simplify locking in Named.resolveUnderlying
+ 2025-10-22 5a42af7f6c go/types, types2: in resolveUnderlying, only compute path when needed
+ 2025-10-22 4bdb55b5b8 go/types, types2: rename Named.under to Named.resolveUnderlying
+ 2025-10-21 29d43df8ab go/build, cmd/go: use ast.ParseDirective for go:embed
+ 2025-10-21 4e695dd634 go/ast: add ParseDirective for parsing directive comments
+ 2025-10-21 06e57e60a7 go/types, types2: only report version errors if new(expr) is ok otherwise
+ 2025-10-21 6c3d0d259f path/filepath: reword documentation for Rel
+ 2025-10-21 39fd61ddb0 go/types, types2: guard Named.underlying with Named.mu
+ 2025-10-21 4a0115c886 runtime,syscall: implement and use syscalln on darwin
+ 2025-10-21 261c561f5a all: gofmt -w
+ 2025-10-21 c9c78c06ef strconv: embed testdata in test
+ 2025-10-21 8f74f9daf4 sync: re-enable race even when panicking
+ 2025-10-21 8a6c64f4fe syscall: use rawSyscall6 to call ptrace in forkAndExecInChild
+ 2025-10-21 4620db72d2 runtime: use timer_settime64 on 32-bit Linux
+ 2025-10-21 b31dc77cea os: support deleting read-only files in RemoveAll on older Windows versions
+ 2025-10-21 46cc532900 cmd/compile/internal/ssa: fix typo in comment
+ 2025-10-21 2163a58021 crypto/internal/fips140/entropy: increase AllocsPerRun iterations
+ 2025-10-21 306eacbc11 cmd/go/testdata/script: disable list_empty_importpath test on Windows
+ 2025-10-21 a5a249d6a6 all: eliminate unnecessary type conversions
+ 2025-10-21 694182d77b cmd/internal/obj/ppc64: improve large prologue generation
+ 2025-10-21 b0dcb95542 cmd/compile: leave the horses alone
+ 2025-10-21 9a5a1202f4 runtime: clean dead architectures from go:build constraint
+ 2025-10-21 8539691d0c crypto/internal/fips140/entropy: move to crypto/internal/entropy/v1.0.0
+ 2025-10-20 99cf4d671c runtime: save lasx and lsx registers in loong64 async preemption
+ 2025-10-20 79ae97fe9b runtime: make procyieldAsm no longer loop infinitely if passed 0
+ 2025-10-20 f838faffe2 runtime: wrap procyield assembly and check for 0
+ 2025-10-20 ee4d2c312d runtime/trace: dump test traces on validation failure
+ 2025-10-20 7b81a1e107 net/url: reduce allocs in Encode
+ 2025-10-20 e425176843 cmd/asm: fix typo in comment
+ 2025-10-20 dc9a3e2a65 runtime: fix generation skew with trace reentrancy
+ 2025-10-20 df33c17091 runtime: add _Gdeadextra status
+ 2025-10-20 7503856d40 cmd/go: inject loaderstate into matcher function
+ 2025-10-20 d57c3fd743 cmd/go: inject State parameter into `work.runInstall`
+ 2025-10-20 e94a5008f6 cmd/go: inject State parameter into `work.runBuild`
+ 2025-10-20 d9e6f95450 cmd/go: inject State parameter into `workcmd.runSync`
+ 2025-10-20 9769a61e64 cmd/go: inject State parameter into `modget.runGet`
+ 2025-10-20 f859799ccf cmd/go: inject State parameter into `modcmd.runVerify`
+ 2025-10-20 0f820aca29 cmd/go: inject State parameter into `modcmd.runVendor`
+ 2025-10-20 92aa3e9e98 cmd/go: inject State parameter into `modcmd.runInit`
+ 2025-10-20 e176dff41c cmd/go: inject State parameter into `modcmd.runDownload`
+ 2025-10-20 e7c66a58d5 cmd/go: inject State parameter into `toolchain.Select`
+ 2025-10-20 4dc3dd9a86 cmd/go: add loaderstate to Switcher
+ 2025-10-20 bcf7da1595 cmd/go: convert functions to methods
+ 2025-10-20 0d3044f965 cmd/go: make Reset work with any State instance
+ 2025-10-20 386d81151d cmd/go: make setState work with any State instance
+ 2025-10-20 a420aa221e cmd/go: inject State parameter into `tool.runTool`
+ 2025-10-20 441e7194a4 cmd/go: inject State parameter into `test.runTest`
+ 2025-10-20 35e8309be2 cmd/go: inject State parameter into `list.runList`
+ 2025-10-20 29a81624f7 cmd/go: inject state parameter into `fmtcmd.runFmt`
+ 2025-10-20 f7eaea02fd cmd/go: inject state parameter into `clean.runClean`
+ 2025-10-20 58a8fdb6cf cmd/go: inject State parameter into `bug.runBug`
+ 2025-10-20 8d0bef7ffe runtime: add linkname documentation and guidance
+ 2025-10-20 3e43f48cb6 encoding/asn1: use reflect.TypeAssert to improve performance
+ 2025-10-20 4ad5585c2c runtime: fix _rt0_ppc64x_lib on aix
+ 2025-10-17 a5f55a441e cmd/fix: add modernize and inline analyzers
+ 2025-10-17 80876f4b42 cmd/go/internal/vet: tweak help doc
+ 2025-10-17 b5aefe07e5 all: remove unnecessary loop variable copies in tests
+ 2025-10-17 5137c473b6 go/types, types2: remove references to under function in comments
+ 2025-10-17 dbbb1bfc91 all: correct name for comments
+ 2025-10-17 0983090171 encoding/pem: properly decode strange PEM data
+ 2025-10-17 36863d6194 runtime: unify riscv64 library entry point
+ 2025-10-16 0c14000f87 go/types, types2: remove under(Type) in favor of Type.Underlying()
+ 2025-10-16 1099436f1b go/types, types2: change and enforce lifecycle of Named.fromRHS and Named.underlying fields
+ 2025-10-16 41f5659347 go/types, types2: remove superfluous unalias call (minor cleanup)
+ 2025-10-16 e7351c03c8 runtime: use DC ZVA instead of its encoding in WORD in arm64 memclr
+ 2025-10-16 6cbe0920c4 cmd: update to x/tools@7d9453cc
+ 2025-10-15 45eee553e2 cmd/internal/obj: move ARM64RegisterExtension from cmd/asm/internal/arch
+ 2025-10-15 27f9a6705c runtime: increase repeat count for alloc test
+ 2025-10-15 b68cebd809 net/http/httptest: record failed ResponseWriter writes
+ 2025-10-15 f1fed742eb cmd: fix three printf problems reported by newest vet
+ 2025-10-15 0984dcd757 cmd/compile: fix an error in comments
+ 2025-10-15 31f82877e8 go/types, types2: fix misleading internal comment
+ 2025-10-15 6346349f56 cmd/compile: replace angle brackets with square
+ 2025-10-15 284379cdfc cmd/compile: remove rematerializable values from live set across calls
+ 2025-10-15 519ae514ab cmd/compile: eliminate bound check for slices of the same length
+ 2025-10-15 b5a29cca48 cmd/distpack: add fix tool to inventory
+ 2025-10-15 bb5eb51715 runtime/pprof: fix errors in pprof_test
+ 2025-10-15 5c9a26c7f8 cmd/compile: use arm64 neon in LoweredMemmove/LoweredMemmoveLoop
+ 2025-10-15 61d1ff61ad cmd/compile: use block starting position for phi line number
+ 2025-10-15 5b29875c8e cmd/go: inject State parameter into `run.runRun`
+ 2025-10-15 5113496805 runtime/pprof: skip flaky test TestProfilerStackDepth/heap for now
+ 2025-10-15 36086e85f8 cmd/go: create temporary cleanup script
+ 2025-10-14 7056c71d32 cmd/compile: disable use of new saturating float-to-int conversions
+ 2025-10-14 6d5b13793f Revert "cmd/compile: make 386 float-to-int conversions match amd64"
+ 2025-10-14 bb2a14252b Revert "runtime: adjust softfloat corner cases to match amd64/arm64"
+ 2025-10-14 3bc9d9fa83 Revert "cmd/compile: make wasm match other platforms for FP->int32/64 conversions"
+ 2025-10-14 ee5af46172 encoding/json: avoid misleading errors under goexperiment.jsonv2
+ 2025-10-14 11d3d2f77d cmd/internal/obj/arm64: add support for PAC instructions
+ 2025-10-14 4dbf1a5a4c cmd/compile/internal/devirtualize: do not track assignments to non-PAUTO
+ 2025-10-14 0ddb5ed465 cmd/compile/internal/devirtualize: use FatalfAt instead of Fatalf where possible
+ 2025-10-14 0a239bcc99 Revert "net/url: disallow raw IPv6 addresses in host"
+ 2025-10-14 5a9ef44bc0 cmd/compile/internal/devirtualize: fix OCONVNOP assertion
+ 2025-10-14 3765758b96 go/types, types2: minor cleanup (remove TODO)
+ 2025-10-14 f6b9d56aff crypto/internal/fips140/entropy: fix benign race
+ 2025-10-14 60f6d2f623 crypto/internal/fips140/entropy: support SHA-384 sizes for ACVP tests
+ 2025-10-13 6fd8e88d07 encoding/json/v2: restrict presence of default options
+ 2025-10-13 1abc6b0204 go/types, types2: permit type cycles through type parameter lists
+ 2025-10-13 9fdd6904da strconv: add tests that Java once mishandled
+ 2025-10-13 9b8742f2e7 cmd/compile: don't depend on arch-dependent conversions in the compiler
+ 2025-10-13 0e64ee1286 encoding/json/v2: report EOF for top-level values in UnmarshalDecode
+ 2025-10-13 6bcd97d9f4 all: replace calls to errors.As with errors.AsType
+ 2025-10-11 1cd71689f2 crypto/x509: rework fix for CVE-2025-58187
+ 2025-10-11 8aa1efa223 cmd/link: in TestFallocate, only check number of blocks on Darwin
+ 2025-10-10 b497a29d25 encoding/json: fix regression in quoted numbers under goexperiment.jsonv2
+ 2025-10-10 48bb7a6114 cmd/compile: repair bisection behavior for float-to-unsigned conversion
+ 2025-10-10 e8a53538b4 runtime: fail TestGoroutineLeakProfile on data race
+ 2025-10-10 e3be2d1b2b net/url: disallow raw IPv6 addresses in host
+ 2025-10-10 aced4c79a2 net/http: strip request body headers on POST to GET redirects
+ 2025-10-10 584a89fe74 all: omit unnecessary reassignment
+ 2025-10-10 69e8279632 net/http: set cookie host to Request.Host when available
+ 2025-10-10 6f4c63ba63 cmd/go: unify "go fix" and "go vet"
+ 2025-10-10 955a5a0dc5 runtime: support arm64 Neon in async preemption
+ 2025-10-10 5368e77429 net/http: run TestRequestWriteTransport with fake time to avoid flakes
+ 2025-10-09 c53cb642de internal/buildcfg: enable greenteagc experiment for loong64
+ 2025-10-09 954fdcc51a cmd/compile: declare no output register for loong64 LoweredAtomic{And,Or}32 ops
+ 2025-10-09 19a30ea3f2 cmd/compile: call generated size-specialized malloc functions directly
+ 2025-10-09 80f3bb5516 reflect: remove timeout in TestChanOfGC
+ 2025-10-09 9db7e30bb4 net/url: allow IP-literals with IPv4-mapped IPv6 addresses
+ 2025-10-09 8d810286b3 cmd/compile: make wasm match other platforms for FP->int32/64 conversions
+ 2025-10-09 b9f3accdcf runtime: adjust softfloat corner cases to match amd64/arm64
+ 2025-10-09 78d75b3799 cmd/compile: make 386 float-to-int conversions match amd64
+ 2025-10-09 0e466a8d1d cmd/compile: modify float-to-[u]int so that amd64 and arm64 match
+ 2025-10-08 4837fbe414 net/http/httptest: check whether response bodies are allowed
+ 2025-10-08 ee163197a8 path/filepath: return cleaned path from Rel
+ 2025-10-08 de9da0de30 cmd/compile/internal/devirtualize: improve concrete type analysis
+ 2025-10-08 ae094a1397 crypto/internal/fips140test: make entropy file pair names match
+ 2025-10-08 941e5917c1 runtime: cleanup comments from asm_ppc64x.s improvements
+ 2025-10-08 d945600d06 cmd/gofmt: change -d to exit 1 if diffs exist
+ 2025-10-08 d4830c6130 cmd/internal/obj: fix Link.Diag printf errors
+ 2025-10-08 e1ca1de123 net/http: format pprof.go
+ 2025-10-08 e5d004c7a8 net/http: update HTTP/2 documentation to reference new config features
+ 2025-10-08 97fd6bdecc cmd/compile: fuse NaN checks with other comparisons
+ 2025-10-07 78b43037dc cmd/go: refactor usage of `workFilePath`
+ 2025-10-07 bb1ca7ae81 cmd/go, testing: add TB.ArtifactDir and -artifacts flag
+ 2025-10-07 1623927730 cmd/go: refactor usage of `requirements`
+ 2025-10-07 a1661e776f Revert "crypto/internal/fips140/subtle: add assembly implementation of xorBytes for mips64x"
+ 2025-10-07 cb81270113 Revert "crypto/internal/fips140/subtle: add assembly implementation of xorBytes for mipsx"
+ 2025-10-07 f2d0d05d28 cmd/go: refactor usage of `MainModules`
+ 2025-10-07 f7a68d3804 archive/tar: set a limit on the size of GNU sparse file 1.0 regions
+ 2025-10-07 463165699d net/mail: avoid quadratic behavior in mail address parsing
+ 2025-10-07 5ede095649 net/textproto: avoid quadratic complexity in Reader.ReadResponse
+ 2025-10-07 5ce8cd16f3 encoding/pem: make Decode complexity linear
+ 2025-10-07 f6f4e8b3ef net/url: enforce stricter parsing of bracketed IPv6 hostnames
+ 2025-10-07 7dd54e1fd7 runtime: make work.spanSPMCs.all doubly-linked
+ 2025-10-07 3ee761739b runtime: free spanQueue on P destroy
+ 2025-10-07 8709a41d5e encoding/asn1: prevent memory exhaustion when parsing using internal/saferio
+ 2025-10-07 9b9d02c5a0 net/http: add httpcookiemaxnum GODEBUG option to limit number of cookies parsed
+ 2025-10-07 3fc4c79fdb crypto/x509: improve domain name verification
+ 2025-10-07 6e4007e8cf crypto/x509: mitigate DoS vector when intermediate certificate contains DSA public key
+ 2025-10-07 6f7926589d cmd/go: refactor usage of `modRoots`
+ 2025-10-07 11d5484190 runtime: fix self-deadlock on sbrk platforms
+ 2025-10-07 2e52060084 cmd/go: refactor usage of `RootMode`
+ 2025-10-07 f86ddb54b5 cmd/go: refactor usage of `ForceUseModules`
+ 2025-10-07 c938051dd0 Revert "cmd/compile: redo arm64 LR/FP save and restore"
+ 2025-10-07 6469954203 runtime: assert p.destroy runs with GC not running
+ 2025-10-06 4c0fd3a2b4 internal/goexperiment: remove the synctest GOEXPERIMENT
+ 2025-10-06 c1e6e49d5d fmt: reduce Errorf("x") allocations to match errors.New("x")
+ 2025-10-06 7fbf54bfeb internal/buildcfg: enable greenteagc experiment by default
+ 2025-10-06 7bfeb43509 cmd/go: refactor usage of `initialized`
+ 2025-10-06 1d62e92567 test/codegen: make sure assignment results are used.
+ 2025-10-06 4fca79833f runtime: delete redundant code in the page allocator
+ 2025-10-06 719dfcf8a8 cmd/compile: redo arm64 LR/FP save and restore
+ 2025-10-06 f3312124c2 runtime: remove batching from spanSPMC free
+ 2025-10-06 24416458c2 cmd/go: export type State
+ 2025-10-06 c2fb15164b testing/synctest: remove Run
+ 2025-10-06 ac2ec82172 runtime: bump thread count slack for TestReadMetricsSched
+ 2025-10-06 e74b224b7c crypto/tls: streamline BoGo testing w/ -bogo-local-dir
+ 2025-10-06 3a05e7b032 spec: close tag
+ 2025-10-03 2a71af11fc net/url: improve URL docs
+ 2025-10-03 ee5369b003 cmd/link: add LIBRARY statement only with -buildmode=cshared
+ 2025-10-03 1bca4c1673 cmd/compile: improve slicemask removal
+ 2025-10-03 38b26f29f1 cmd/compile: remove stores to unread parameters
+ 2025-10-03 003b5ce1bc cmd/compile: fix SIMD const rematerialization condition
+ 2025-10-03 d91148c7a8 cmd/compile: enhance prove to infer bounds in slice len/cap calculations
+ 2025-10-03 20c9377e47 cmd/compile: enhance the chunked indexing case to include reslicing
+ 2025-10-03 ad3db2562e cmd/compile: handle rematerialized op for incompatible reg constraint
+ 2025-10-03 18cd4a1fc7 cmd/compile: use the right type for spill slot
+ 2025-10-03 1caa95acfa cmd/compile: enhance prove to deal with double-offset IsInBounds checks
+ 2025-10-03 ec70d19023 cmd/compile: rewrite to elide Slicemask from len==c>0 slicing
+ 2025-10-03 10e7968849 cmd/compile: accounts rematerialize ops's output reginfo
+ 2025-10-03 ab043953cb cmd/compile: minor tweak for race detector
+ 2025-10-03 ebb72bef44 cmd/compile: don't treat devel compiler as a released compiler
+ 2025-10-03 c54dc1418b runtime: support valgrind (but not asan) in specialized malloc functions
+ 2025-10-03 a7917eed70 internal/buildcfg: enable specializedmalloc experiment
+ 2025-10-03 630799c6c9 crypto/tls: add flag to render HTML BoGo report

Change-Id: I6bf904c523a77ee7d3dea9c8ae72292f8a5f2ba5
This commit is contained in:
Cherry Mui 2025-11-13 16:43:45 -05:00
commit d7a0c45642
1155 changed files with 57745 additions and 19718 deletions
Download patch file Download diff file Expand all files Collapse all files

2
test/codegen/addrcalc.go
View file

@ -9,6 +9,6 @@ package codegen
// Make sure we use ADDQ instead of LEAQ when we can.
func f(p *[4][2]int, x int) *int {
// amd64:"ADDQ",-"LEAQ"
// amd64:"ADDQ" -"LEAQ"
return &p[x][0]
}

30
test/codegen/alloc.go
View file

@ -10,28 +10,28 @@
package codegen
func zeroAllocNew1() *struct{} {
// 386:-`CALL\truntime\.newobject`, `LEAL\truntime.zerobase`
// amd64:-`CALL\truntime\.newobject`, `LEAQ\truntime.zerobase`
// arm:-`CALL\truntime\.newobject`, `MOVW\t[$]runtime.zerobase`
// arm64:-`CALL\truntime\.newobject`, `MOVD\t[$]runtime.zerobase`
// riscv64:-`CALL\truntime\.newobject`, `MOV\t[$]runtime.zerobase`
// 386:-`CALL runtime\.newobject`, `LEAL runtime.zerobase`
// amd64:-`CALL runtime\.newobject`, `LEAQ runtime.zerobase`
// arm:-`CALL runtime\.newobject`, `MOVW [$]runtime.zerobase`
// arm64:-`CALL runtime\.newobject`, `MOVD [$]runtime.zerobase`
// riscv64:-`CALL runtime\.newobject`, `MOV [$]runtime.zerobase`
return new(struct{})
}
func zeroAllocNew2() *[0]int {
// 386:-`CALL\truntime\.newobject`, `LEAL\truntime.zerobase`
// amd64:-`CALL\truntime\.newobject`, `LEAQ\truntime.zerobase`
// arm:-`CALL\truntime\.newobject`, `MOVW\t[$]runtime.zerobase`
// arm64:-`CALL\truntime\.newobject`, `MOVD\t[$]runtime.zerobase`
// riscv64:-`CALL\truntime\.newobject`, `MOV\t[$]runtime.zerobase`
// 386:-`CALL runtime\.newobject`, `LEAL runtime.zerobase`
// amd64:-`CALL runtime\.newobject`, `LEAQ runtime.zerobase`
// arm:-`CALL runtime\.newobject`, `MOVW [$]runtime.zerobase`
// arm64:-`CALL runtime\.newobject`, `MOVD [$]runtime.zerobase`
// riscv64:-`CALL runtime\.newobject`, `MOV [$]runtime.zerobase`
return new([0]int)
}
func zeroAllocSliceLit() []int {
// 386:-`CALL\truntime\.newobject`, `LEAL\truntime.zerobase`
// amd64:-`CALL\truntime\.newobject`, `LEAQ\truntime.zerobase`
// arm:-`CALL\truntime\.newobject`, `MOVW\t[$]runtime.zerobase`
// arm64:-`CALL\truntime\.newobject`, `MOVD\t[$]runtime.zerobase`
// riscv64:-`CALL\truntime\.newobject`, `MOV\t[$]runtime.zerobase`
// 386:-`CALL runtime\.newobject`, `LEAL runtime.zerobase`
// amd64:-`CALL runtime\.newobject`, `LEAQ runtime.zerobase`
// arm:-`CALL runtime\.newobject`, `MOVW [$]runtime.zerobase`
// arm64:-`CALL runtime\.newobject`, `MOVD [$]runtime.zerobase`
// riscv64:-`CALL runtime\.newobject`, `MOV [$]runtime.zerobase`
return []int{}
}

499
test/codegen/arithmetic.go
View file

@ -10,55 +10,51 @@ package codegen
// simplifications and optimizations on integer types.
// For codegen tests on float types, see floats.go.
// ----------------- //
// Addition //
// ----------------- //
// Addition
func AddLargeConst(a uint64, out []uint64) {
// ppc64x/power10:"ADD\t[$]4294967296,"
// ppc64x/power9:"MOVD\t[$]1", "SLD\t[$]32" "ADD\tR[0-9]*"
// ppc64x/power8:"MOVD\t[$]1", "SLD\t[$]32" "ADD\tR[0-9]*"
// ppc64x/power10:"ADD [$]4294967296,"
// ppc64x/power9:"MOVD [$]1", "SLD [$]32" "ADD R[0-9]*"
// ppc64x/power8:"MOVD [$]1", "SLD [$]32" "ADD R[0-9]*"
out[0] = a + 0x100000000
// ppc64x/power10:"ADD\t[$]-8589934592,"
// ppc64x/power9:"MOVD\t[$]-1", "SLD\t[$]33" "ADD\tR[0-9]*"
// ppc64x/power8:"MOVD\t[$]-1", "SLD\t[$]33" "ADD\tR[0-9]*"
// ppc64x/power10:"ADD [$]-8589934592,"
// ppc64x/power9:"MOVD [$]-1", "SLD [$]33" "ADD R[0-9]*"
// ppc64x/power8:"MOVD [$]-1", "SLD [$]33" "ADD R[0-9]*"
out[1] = a + 0xFFFFFFFE00000000
// ppc64x/power10:"ADD\t[$]1234567,"
// ppc64x/power9:"ADDIS\t[$]19,", "ADD\t[$]-10617,"
// ppc64x/power8:"ADDIS\t[$]19,", "ADD\t[$]-10617,"
// ppc64x/power10:"ADD [$]1234567,"
// ppc64x/power9:"ADDIS [$]19,", "ADD [$]-10617,"
// ppc64x/power8:"ADDIS [$]19,", "ADD [$]-10617,"
out[2] = a + 1234567
// ppc64x/power10:"ADD\t[$]-1234567,"
// ppc64x/power9:"ADDIS\t[$]-19,", "ADD\t[$]10617,"
// ppc64x/power8:"ADDIS\t[$]-19,", "ADD\t[$]10617,"
// ppc64x/power10:"ADD [$]-1234567,"
// ppc64x/power9:"ADDIS [$]-19,", "ADD [$]10617,"
// ppc64x/power8:"ADDIS [$]-19,", "ADD [$]10617,"
out[3] = a - 1234567
// ppc64x/power10:"ADD\t[$]2147450879,"
// ppc64x/power9:"ADDIS\t[$]32767,", "ADD\t[$]32767,"
// ppc64x/power8:"ADDIS\t[$]32767,", "ADD\t[$]32767,"
// ppc64x/power10:"ADD [$]2147450879,"
// ppc64x/power9:"ADDIS [$]32767,", "ADD [$]32767,"
// ppc64x/power8:"ADDIS [$]32767,", "ADD [$]32767,"
out[4] = a + 0x7FFF7FFF
// ppc64x/power10:"ADD\t[$]-2147483647,"
// ppc64x/power9:"ADDIS\t[$]-32768,", "ADD\t[$]1,"
// ppc64x/power8:"ADDIS\t[$]-32768,", "ADD\t[$]1,"
// ppc64x/power10:"ADD [$]-2147483647,"
// ppc64x/power9:"ADDIS [$]-32768,", "ADD [$]1,"
// ppc64x/power8:"ADDIS [$]-32768,", "ADD [$]1,"
out[5] = a - 2147483647
// ppc64x:"ADDIS\t[$]-32768,", ^"ADD\t"
// ppc64x:"ADDIS [$]-32768,", ^"ADD "
out[6] = a - 2147483648
// ppc64x:"ADD\t[$]2147450880,", ^"ADDIS\t"
// ppc64x:"ADD [$]2147450880,", ^"ADDIS "
out[7] = a + 0x7FFF8000
// ppc64x:"ADD\t[$]-32768,", ^"ADDIS\t"
// ppc64x:"ADD [$]-32768,", ^"ADDIS "
out[8] = a - 32768
// ppc64x/power10:"ADD\t[$]-32769,"
// ppc64x/power9:"ADDIS\t[$]-1,", "ADD\t[$]32767,"
// ppc64x/power8:"ADDIS\t[$]-1,", "ADD\t[$]32767,"
// ppc64x/power10:"ADD [$]-32769,"
// ppc64x/power9:"ADDIS [$]-1,", "ADD [$]32767,"
// ppc64x/power8:"ADDIS [$]-1,", "ADD [$]32767,"
out[9] = a - 32769
}
func AddLargeConst2(a int, out []int) {
// loong64: -"ADDVU","ADDV16"
// loong64: -"ADDVU" "ADDV16"
out[0] = a + 0x10000
}
// ----------------- //
// Subtraction //
// ----------------- //
// Subtraction
var ef int
@ -83,65 +79,65 @@ func SubMem(arr []int, b, c, d int) int {
arr[b]--
// amd64:`DECQ\s64\([A-Z]+\)`
arr[8]--
// 386:"SUBL\t4"
// amd64:"SUBQ\t8"
// 386:"SUBL 4"
// amd64:"SUBQ 8"
return arr[0] - arr[1]
}
func SubFromConst(a int) int {
// ppc64x: `SUBC\tR[0-9]+,\s[$]40,\sR`
// riscv64: "ADDI\t\\$-40","NEG"
// ppc64x: `SUBC R[0-9]+,\s[$]40,\sR`
// riscv64: "ADDI [$]-40" "NEG"
b := 40 - a
return b
}
func SubFromConstNeg(a int) int {
// arm64: "ADD\t\\$40"
// loong64: "ADDV[U]\t\\$40"
// mips: "ADD[U]\t\\$40"
// mips64: "ADDV[U]\t\\$40"
// ppc64x: `ADD\t[$]40,\sR[0-9]+,\sR`
// riscv64: "ADDI\t\\$40",-"NEG"
// arm64: "ADD [$]40"
// loong64: "ADDV[U] [$]40"
// mips: "ADD[U] [$]40"
// mips64: "ADDV[U] [$]40"
// ppc64x: `ADD [$]40,\sR[0-9]+,\sR`
// riscv64: "ADDI [$]40" -"NEG"
c := 40 - (-a)
return c
}
func SubSubFromConst(a int) int {
// arm64: "ADD\t\\$20"
// loong64: "ADDV[U]\t\\$20"
// mips: "ADD[U]\t\\$20"
// mips64: "ADDV[U]\t\\$20"
// ppc64x: `ADD\t[$]20,\sR[0-9]+,\sR`
// riscv64: "ADDI\t\\$20",-"NEG"
// arm64: "ADD [$]20"
// loong64: "ADDV[U] [$]20"
// mips: "ADD[U] [$]20"
// mips64: "ADDV[U] [$]20"
// ppc64x: `ADD [$]20,\sR[0-9]+,\sR`
// riscv64: "ADDI [$]20" -"NEG"
c := 40 - (20 - a)
return c
}
func AddSubFromConst(a int) int {
// ppc64x: `SUBC\tR[0-9]+,\s[$]60,\sR`
// riscv64: "ADDI\t\\$-60","NEG"
// ppc64x: `SUBC R[0-9]+,\s[$]60,\sR`
// riscv64: "ADDI [$]-60" "NEG"
c := 40 + (20 - a)
return c
}
func NegSubFromConst(a int) int {
// arm64: "SUB\t\\$20"
// loong64: "ADDV[U]\t\\$-20"
// mips: "ADD[U]\t\\$-20"
// mips64: "ADDV[U]\t\\$-20"
// ppc64x: `ADD\t[$]-20,\sR[0-9]+,\sR`
// riscv64: "ADDI\t\\$-20"
// arm64: "SUB [$]20"
// loong64: "ADDV[U] [$]-20"
// mips: "ADD[U] [$]-20"
// mips64: "ADDV[U] [$]-20"
// ppc64x: `ADD [$]-20,\sR[0-9]+,\sR`
// riscv64: "ADDI [$]-20"
c := -(20 - a)
return c
}
func NegAddFromConstNeg(a int) int {
// arm64: "SUB\t\\$40","NEG"
// loong64: "ADDV[U]\t\\$-40","SUBV"
// mips: "ADD[U]\t\\$-40","SUB"
// mips64: "ADDV[U]\t\\$-40","SUBV"
// ppc64x: `SUBC\tR[0-9]+,\s[$]40,\sR`
// riscv64: "ADDI\t\\$-40","NEG"
// arm64: "SUB [$]40" "NEG"
// loong64: "ADDV[U] [$]-40" "SUBV"
// mips: "ADD[U] [$]-40" "SUB"
// mips64: "ADDV[U] [$]-40" "SUBV"
// ppc64x: `SUBC R[0-9]+,\s[$]40,\sR`
// riscv64: "ADDI [$]-40" "NEG"
c := -(-40 + a)
return c
}
@ -153,19 +149,19 @@ func SubSubNegSimplify(a, b int) int {
// mips:"SUB"
// mips64:"SUBV"
// ppc64x:"NEG"
// riscv64:"NEG",-"SUB"
// riscv64:"NEG" -"SUB"
r := (a - b) - a
return r
}
func SubAddSimplify(a, b int) int {
// amd64:-"SUBQ",-"ADDQ"
// arm64:-"SUB",-"ADD"
// loong64:-"SUBV",-"ADDV"
// mips:-"SUB",-"ADD"
// mips64:-"SUBV",-"ADDV"
// ppc64x:-"SUB",-"ADD"
// riscv64:-"SUB",-"ADD"
// amd64:-"SUBQ" -"ADDQ"
// arm64:-"SUB" -"ADD"
// loong64:-"SUBV" -"ADDV"
// mips:-"SUB" -"ADD"
// mips64:-"SUBV" -"ADDV"
// ppc64x:-"SUB" -"ADD"
// riscv64:-"SUB" -"ADD"
r := a + (b - a)
return r
}
@ -173,9 +169,9 @@ func SubAddSimplify(a, b int) int {
func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) {
// amd64:-"ADDQ"
// arm64:-"ADD"
// mips:"SUB",-"ADD"
// mips64:"SUBV",-"ADDV"
// loong64:"SUBV",-"ADDV"
// mips:"SUB" -"ADD"
// mips64:"SUBV" -"ADDV"
// loong64:"SUBV" -"ADDV"
r := (a + b) - (a + c)
// amd64:-"ADDQ"
r1 := (a + b) - (c + a)
@ -185,9 +181,9 @@ func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) {
r3 := (b + a) - (c + a)
// amd64:-"SUBQ"
// arm64:-"SUB"
// mips:"ADD",-"SUB"
// mips64:"ADDV",-"SUBV"
// loong64:"ADDV",-"SUBV"
// mips:"ADD" -"SUB"
// mips64:"ADDV" -"SUBV"
// loong64:"ADDV" -"SUBV"
r4 := (a - c) + (c + b)
// amd64:-"SUBQ"
r5 := (a - c) + (b + c)
@ -195,31 +191,31 @@ func SubAddSimplify2(a, b, c int) (int, int, int, int, int, int) {
}
func SubAddNegSimplify(a, b int) int {
// amd64:"NEGQ",-"ADDQ",-"SUBQ"
// arm64:"NEG",-"ADD",-"SUB"
// loong64:"SUBV",-"ADDV"
// mips:"SUB",-"ADD"
// mips64:"SUBV",-"ADDV"
// ppc64x:"NEG",-"ADD",-"SUB"
// riscv64:"NEG",-"ADD",-"SUB"
// amd64:"NEGQ" -"ADDQ" -"SUBQ"
// arm64:"NEG" -"ADD" -"SUB"
// loong64:"SUBV" -"ADDV"
// mips:"SUB" -"ADD"
// mips64:"SUBV" -"ADDV"
// ppc64x:"NEG" -"ADD" -"SUB"
// riscv64:"NEG" -"ADD" -"SUB"
r := a - (b + a)
return r
}
func AddAddSubSimplify(a, b, c int) int {
// amd64:-"SUBQ"
// arm64:"ADD",-"SUB"
// loong64:"ADDV",-"SUBV"
// mips:"ADD",-"SUB"
// mips64:"ADDV",-"SUBV"
// arm64:"ADD" -"SUB"
// loong64:"ADDV" -"SUBV"
// mips:"ADD" -"SUB"
// mips64:"ADDV" -"SUBV"
// ppc64x:-"SUB"
// riscv64:"ADD","ADD",-"SUB"
// riscv64:"ADD" "ADD" -"SUB"
r := a + (b + (c - a))
return r
}
func NegToInt32(a int) int {
// riscv64: "NEGW",-"MOVW"
// riscv64: "NEGW" -"MOVW"
r := int(int32(-a))
return r
}
@ -229,20 +225,20 @@ func NegToInt32(a int) int {
// -------------------- //
func Pow2Muls(n1, n2 int) (int, int) {
// amd64:"SHLQ\t[$]5",-"IMULQ"
// 386:"SHLL\t[$]5",-"IMULL"
// arm:"SLL\t[$]5",-"MUL"
// arm64:"LSL\t[$]5",-"MUL"
// loong64:"SLLV\t[$]5",-"MULV"
// ppc64x:"SLD\t[$]5",-"MUL"
// amd64:"SHLQ [$]5" -"IMULQ"
// 386:"SHLL [$]5" -"IMULL"
// arm:"SLL [$]5" -"MUL"
// arm64:"LSL [$]5" -"MUL"
// loong64:"SLLV [$]5" -"MULV"
// ppc64x:"SLD [$]5" -"MUL"
a := n1 * 32
// amd64:"SHLQ\t[$]6",-"IMULQ"
// 386:"SHLL\t[$]6",-"IMULL"
// arm:"SLL\t[$]6",-"MUL"
// amd64:"SHLQ [$]6" -"IMULQ"
// 386:"SHLL [$]6" -"IMULL"
// arm:"SLL [$]6" -"MUL"
// arm64:`NEG\sR[0-9]+<<6,\sR[0-9]+`,-`LSL`,-`MUL`
// loong64:"SLLV\t[$]6",-"MULV"
// ppc64x:"SLD\t[$]6","NEG\\sR[0-9]+,\\sR[0-9]+",-"MUL"
// loong64:"SLLV [$]6" -"MULV"
// ppc64x:"SLD [$]6" "NEG\\sR[0-9]+,\\sR[0-9]+" -"MUL"
b := -64 * n2
return a, b
@ -258,18 +254,18 @@ func Mul_2(n1 int32, n2 int64) (int32, int64) {
}
func Mul_96(n int) int {
// amd64:`SHLQ\t[$]5`,`LEAQ\t\(.*\)\(.*\*2\),`,-`IMULQ`
// 386:`SHLL\t[$]5`,`LEAL\t\(.*\)\(.*\*2\),`,-`IMULL`
// arm64:`LSL\t[$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
// arm:`SLL\t[$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
// loong64:"SLLV\t[$]5","ALSLV\t[$]1,"
// s390x:`SLD\t[$]5`,`SLD\t[$]6`,-`MULLD`
// amd64:`SHLQ [$]5`,`LEAQ \(.*\)\(.*\*2\),`,-`IMULQ`
// 386:`SHLL [$]5`,`LEAL \(.*\)\(.*\*2\),`,-`IMULL`
// arm64:`LSL [$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
// arm:`SLL [$]5`,`ADD\sR[0-9]+<<1,\sR[0-9]+`,-`MUL`
// loong64:"SLLV [$]5" "ALSLV [$]1,"
// s390x:`SLD [$]5`,`SLD [$]6`,-`MULLD`
return n * 96
}
func Mul_n120(n int) int {
// loong64:"SLLV\t[$]3","SLLV\t[$]7","SUBVU",-"MULV"
// s390x:`SLD\t[$]3`,`SLD\t[$]7`,-`MULLD`
// loong64:"SLLV [$]3" "SLLV [$]7" "SUBVU" -"MULV"
// s390x:`SLD [$]3`,`SLD [$]7`,-`MULLD`
return n * -120
}
@ -284,50 +280,50 @@ func MulMemSrc(a []uint32, b []float32) {
// Multiplications merging tests
func MergeMuls1(n int) int {
// amd64:"IMUL3Q\t[$]46"
// 386:"IMUL3L\t[$]46"
// ppc64x:"MULLD\t[$]46"
// amd64:"IMUL3Q [$]46"
// 386:"IMUL3L [$]46"
// ppc64x:"MULLD [$]46"
return 15*n + 31*n // 46n
}
func MergeMuls2(n int) int {
// amd64:"IMUL3Q\t[$]23","(ADDQ\t[$]29)|(LEAQ\t29)"
// 386:"IMUL3L\t[$]23","ADDL\t[$]29"
// ppc64x/power9:"MADDLD",-"MULLD\t[$]23",-"ADD\t[$]29"
// ppc64x/power8:"MULLD\t[$]23","ADD\t[$]29"
// amd64:"IMUL3Q [$]23" "(ADDQ [$]29)|(LEAQ 29)"
// 386:"IMUL3L [$]23" "ADDL [$]29"
// ppc64x/power9:"MADDLD" -"MULLD [$]23" -"ADD [$]29"
// ppc64x/power8:"MULLD [$]23" "ADD [$]29"
return 5*n + 7*(n+1) + 11*(n+2) // 23n + 29
}
func MergeMuls3(a, n int) int {
// amd64:"ADDQ\t[$]19",-"IMULQ\t[$]19"
// 386:"ADDL\t[$]19",-"IMULL\t[$]19"
// ppc64x:"ADD\t[$]19",-"MULLD\t[$]19"
// amd64:"ADDQ [$]19" -"IMULQ [$]19"
// 386:"ADDL [$]19" -"IMULL [$]19"
// ppc64x:"ADD [$]19" -"MULLD [$]19"
return a*n + 19*n // (a+19)n
}
func MergeMuls4(n int) int {
// amd64:"IMUL3Q\t[$]14"
// 386:"IMUL3L\t[$]14"
// ppc64x:"MULLD\t[$]14"
// amd64:"IMUL3Q [$]14"
// 386:"IMUL3L [$]14"
// ppc64x:"MULLD [$]14"
return 23*n - 9*n // 14n
}
func MergeMuls5(a, n int) int {
// amd64:"ADDQ\t[$]-19",-"IMULQ\t[$]19"
// 386:"ADDL\t[$]-19",-"IMULL\t[$]19"
// ppc64x:"ADD\t[$]-19",-"MULLD\t[$]19"
// amd64:"ADDQ [$]-19" -"IMULQ [$]19"
// 386:"ADDL [$]-19" -"IMULL [$]19"
// ppc64x:"ADD [$]-19" -"MULLD [$]19"
return a*n - 19*n // (a-19)n
}
// Multiplications folded negation
func FoldNegMul(a int) int {
// loong64:"SUBVU","ALSLV\t[$]2","ALSLV\t[$]1"
// loong64:"SUBVU" "ALSLV [$]2" "ALSLV [$]1"
return (-a) * 11
}
func Fold2NegMul(a, b int) int {
// loong64:"MULV",-"SUBVU\tR[0-9], R0,"
// loong64:"MULV" -"SUBVU R[0-9], R0,"
return (-a) * (-b)
}
@ -342,17 +338,17 @@ func DivMemSrc(a []float64) {
}
func Pow2Divs(n1 uint, n2 int) (uint, int) {
// 386:"SHRL\t[$]5",-"DIVL"
// amd64:"SHRQ\t[$]5",-"DIVQ"
// arm:"SRL\t[$]5",-".*udiv"
// arm64:"LSR\t[$]5",-"UDIV"
// 386:"SHRL [$]5" -"DIVL"
// amd64:"SHRQ [$]5" -"DIVQ"
// arm:"SRL [$]5" -".*udiv"
// arm64:"LSR [$]5" -"UDIV"
// ppc64x:"SRD"
a := n1 / 32 // unsigned
// amd64:"SARQ\t[$]6",-"IDIVQ"
// 386:"SARL\t[$]6",-"IDIVL"
// arm:"SRA\t[$]6",-".*udiv"
// arm64:"ASR\t[$]6",-"SDIV"
// amd64:"SARQ [$]6" -"IDIVQ"
// 386:"SARL [$]6" -"IDIVL"
// arm:"SRA [$]6" -".*udiv"
// arm64:"ASR [$]6" -"SDIV"
// ppc64x:"SRAD"
b := n2 / 64 // signed
@ -361,16 +357,16 @@ func Pow2Divs(n1 uint, n2 int) (uint, int) {
// Check that constant divisions get turned into MULs
func ConstDivs(n1 uint, n2 int) (uint, int) {
// amd64:"MOVQ\t[$]-1085102592571150095","MULQ",-"DIVQ"
// 386:"MOVL\t[$]-252645135","MULL",-"DIVL"
// arm64:`MOVD`,`UMULH`,-`DIV`
// arm:`MOVW`,`MUL`,-`.*udiv`
// amd64: "MOVQ [$]-1085102592571150095" "MULQ" -"DIVQ"
// 386: "MOVL [$]-252645135" "MULL" -"DIVL"
// arm64: `MOVD`,`UMULH`,-`DIV`
// arm: `MOVW`,`MUL`,-`.*udiv`
a := n1 / 17 // unsigned
// amd64:"MOVQ\t[$]-1085102592571150095","IMULQ",-"IDIVQ"
// 386:"MOVL\t[$]-252645135","IMULL",-"IDIVL"
// arm64:`SMULH`,-`DIV`
// arm:`MOVW`,`MUL`,-`.*udiv`
// amd64: "MOVQ [$]-1085102592571150095" "IMULQ" -"IDIVQ"
// 386: "IMULL" "SARL [$]4," "SARL [$]31," "SUBL" -".*DIV"
// arm64: `SMULH` -`DIV`
// arm: `MOVW` `MUL` -`.*udiv`
b := n2 / 17 // signed
return a, b
@ -383,17 +379,17 @@ func FloatDivs(a []float32) float32 {
}
func Pow2Mods(n1 uint, n2 int) (uint, int) {
// 386:"ANDL\t[$]31",-"DIVL"
// amd64:"ANDL\t[$]31",-"DIVQ"
// arm:"AND\t[$]31",-".*udiv"
// arm64:"AND\t[$]31",-"UDIV"
// 386:"ANDL [$]31" -"DIVL"
// amd64:"ANDL [$]31" -"DIVQ"
// arm:"AND [$]31" -".*udiv"
// arm64:"AND [$]31" -"UDIV"
// ppc64x:"RLDICL"
a := n1 % 32 // unsigned
// 386:"SHRL",-"IDIVL"
// amd64:"SHRQ",-"IDIVQ"
// arm:"SRA",-".*udiv"
// arm64:"ASR",-"REM"
// 386:"SHRL" -"IDIVL"
// amd64:"SHRQ" -"IDIVQ"
// arm:"SRA" -".*udiv"
// arm64:"ASR" -"REM"
// ppc64x:"SRAD"
b := n2 % 64 // signed
@ -402,18 +398,18 @@ func Pow2Mods(n1 uint, n2 int) (uint, int) {
// Check that signed divisibility checks get converted to AND on low bits
func Pow2DivisibleSigned(n1, n2 int) (bool, bool) {
// 386:"TESTL\t[$]63",-"DIVL",-"SHRL"
// amd64:"TESTQ\t[$]63",-"DIVQ",-"SHRQ"
// arm:"AND\t[$]63",-".*udiv",-"SRA"
// arm64:"TST\t[$]63",-"UDIV",-"ASR",-"AND"
// ppc64x:"ANDCC",-"RLDICL",-"SRAD",-"CMP"
// 386:"TESTL [$]63" -"DIVL" -"SHRL"
// amd64:"TESTQ [$]63" -"DIVQ" -"SHRQ"
// arm:"AND [$]63" -".*udiv" -"SRA"
// arm64:"TST [$]63" -"UDIV" -"ASR" -"AND"
// ppc64x:"ANDCC" -"RLDICL" -"SRAD" -"CMP"
a := n1%64 == 0 // signed divisible
// 386:"TESTL\t[$]63",-"DIVL",-"SHRL"
// amd64:"TESTQ\t[$]63",-"DIVQ",-"SHRQ"
// arm:"AND\t[$]63",-".*udiv",-"SRA"
// arm64:"TST\t[$]63",-"UDIV",-"ASR",-"AND"
// ppc64x:"ANDCC",-"RLDICL",-"SRAD",-"CMP"
// 386:"TESTL [$]63" -"DIVL" -"SHRL"
// amd64:"TESTQ [$]63" -"DIVQ" -"SHRQ"
// arm:"AND [$]63" -".*udiv" -"SRA"
// arm64:"TST [$]63" -"UDIV" -"ASR" -"AND"
// ppc64x:"ANDCC" -"RLDICL" -"SRAD" -"CMP"
b := n2%64 != 0 // signed indivisible
return a, b
@ -421,16 +417,16 @@ func Pow2DivisibleSigned(n1, n2 int) (bool, bool) {
// Check that constant modulo divs get turned into MULs
func ConstMods(n1 uint, n2 int) (uint, int) {
// amd64:"MOVQ\t[$]-1085102592571150095","MULQ",-"DIVQ"
// 386:"MOVL\t[$]-252645135","MULL",-"DIVL"
// arm64:`MOVD`,`UMULH`,-`DIV`
// arm:`MOVW`,`MUL`,-`.*udiv`
// amd64: "MOVQ [$]-1085102592571150095" "MULQ" -"DIVQ"
// 386: "MOVL [$]-252645135" "MULL" -".*DIVL"
// arm64: `MOVD` `UMULH` -`DIV`
// arm: `MOVW` `MUL` -`.*udiv`
a := n1 % 17 // unsigned
// amd64:"MOVQ\t[$]-1085102592571150095","IMULQ",-"IDIVQ"
// 386:"MOVL\t[$]-252645135","IMULL",-"IDIVL"
// arm64:`SMULH`,-`DIV`
// arm:`MOVW`,`MUL`,-`.*udiv`
// amd64: "MOVQ [$]-1085102592571150095" "IMULQ" -"IDIVQ"
// 386: "IMULL" "SARL [$]4," "SARL [$]31," "SUBL" "SHLL [$]4," "SUBL" -".*DIV"
// arm64: `SMULH` -`DIV`
// arm: `MOVW` `MUL` -`.*udiv`
b := n2 % 17 // signed
return a, b
@ -438,38 +434,38 @@ func ConstMods(n1 uint, n2 int) (uint, int) {
// Check that divisibility checks x%c==0 are converted to MULs and rotates
func DivisibleU(n uint) (bool, bool) {
// amd64:"MOVQ\t[$]-6148914691236517205","IMULQ","ROLQ\t[$]63",-"DIVQ"
// 386:"IMUL3L\t[$]-1431655765","ROLL\t[$]31",-"DIVQ"
// arm64:"MOVD\t[$]-6148914691236517205","MOVD\t[$]3074457345618258602","MUL","ROR",-"DIV"
// arm:"MUL","CMP\t[$]715827882",-".*udiv"
// ppc64x:"MULLD","ROTL\t[$]63"
// amd64:"MOVQ [$]-6148914691236517205" "IMULQ" "ROLQ [$]63" -"DIVQ"
// 386:"IMUL3L [$]-1431655765" "ROLL [$]31" -"DIVQ"
// arm64:"MOVD [$]-6148914691236517205" "MOVD [$]3074457345618258602" "MUL" "ROR" -"DIV"
// arm:"MUL" "CMP [$]715827882" -".*udiv"
// ppc64x:"MULLD" "ROTL [$]63"
even := n%6 == 0
// amd64:"MOVQ\t[$]-8737931403336103397","IMULQ",-"ROLQ",-"DIVQ"
// 386:"IMUL3L\t[$]678152731",-"ROLL",-"DIVQ"
// arm64:"MOVD\t[$]-8737931403336103397","MUL",-"ROR",-"DIV"
// arm:"MUL","CMP\t[$]226050910",-".*udiv"
// ppc64x:"MULLD",-"ROTL"
// amd64:"MOVQ [$]-8737931403336103397" "IMULQ" -"ROLQ" -"DIVQ"
// 386:"IMUL3L [$]678152731" -"ROLL" -"DIVQ"
// arm64:"MOVD [$]-8737931403336103397" "MUL" -"ROR" -"DIV"
// arm:"MUL" "CMP [$]226050910" -".*udiv"
// ppc64x:"MULLD" -"ROTL"
odd := n%19 == 0
return even, odd
}
func Divisible(n int) (bool, bool) {
// amd64:"IMULQ","ADD","ROLQ\t[$]63",-"DIVQ"
// 386:"IMUL3L\t[$]-1431655765","ADDL\t[$]715827882","ROLL\t[$]31",-"DIVQ"
// arm64:"MOVD\t[$]-6148914691236517205","MOVD\t[$]3074457345618258602","MUL","ADD\tR","ROR",-"DIV"
// arm:"MUL","ADD\t[$]715827882",-".*udiv"
// ppc64x/power8:"MULLD","ADD","ROTL\t[$]63"
// ppc64x/power9:"MADDLD","ROTL\t[$]63"
// amd64:"IMULQ" "ADD" "ROLQ [$]63" -"DIVQ"
// 386:"IMUL3L [$]-1431655765" "ADDL [$]715827882" "ROLL [$]31" -"DIVQ"
// arm64:"MOVD [$]-6148914691236517205" "MOVD [$]3074457345618258602" "MUL" "ADD R" "ROR" -"DIV"
// arm:"MUL" "ADD [$]715827882" -".*udiv"
// ppc64x/power8:"MULLD" "ADD" "ROTL [$]63"
// ppc64x/power9:"MADDLD" "ROTL [$]63"
even := n%6 == 0
// amd64:"IMULQ","ADD",-"ROLQ",-"DIVQ"
// 386:"IMUL3L\t[$]678152731","ADDL\t[$]113025455",-"ROLL",-"DIVQ"
// arm64:"MUL","MOVD\t[$]485440633518672410","ADD",-"ROR",-"DIV"
// arm:"MUL","ADD\t[$]113025455",-".*udiv"
// ppc64x/power8:"MULLD","ADD",-"ROTL"
// ppc64x/power9:"MADDLD",-"ROTL"
// amd64:"IMULQ" "ADD" -"ROLQ" -"DIVQ"
// 386:"IMUL3L [$]678152731" "ADDL [$]113025455" -"ROLL" -"DIVQ"
// arm64:"MUL" "MOVD [$]485440633518672410" "ADD" -"ROR" -"DIV"
// arm:"MUL" "ADD [$]113025455" -".*udiv"
// ppc64x/power8:"MULLD" "ADD" -"ROTL"
// ppc64x/power9:"MADDLD" -"ROTL"
odd := n%19 == 0
return even, odd
@ -568,64 +564,64 @@ func NoFix16B(divd int16) (int16, int16) {
// optimized into shifts and ands
func LenDiv1(a []int) int {
// 386:"SHRL\t[$]10"
// amd64:"SHRQ\t[$]10"
// arm64:"LSR\t[$]10",-"SDIV"
// arm:"SRL\t[$]10",-".*udiv"
// ppc64x:"SRD"\t[$]10"
// 386:"SHRL [$]10"
// amd64:"SHRQ [$]10"
// arm64:"LSR [$]10" -"SDIV"
// arm:"SRL [$]10" -".*udiv"
// ppc64x:"SRD" [$]10"
return len(a) / 1024
}
func LenDiv2(s string) int {
// 386:"SHRL\t[$]11"
// amd64:"SHRQ\t[$]11"
// arm64:"LSR\t[$]11",-"SDIV"
// arm:"SRL\t[$]11",-".*udiv"
// ppc64x:"SRD\t[$]11"
// 386:"SHRL [$]11"
// amd64:"SHRQ [$]11"
// arm64:"LSR [$]11" -"SDIV"
// arm:"SRL [$]11" -".*udiv"
// ppc64x:"SRD [$]11"
return len(s) / (4097 >> 1)
}
func LenMod1(a []int) int {
// 386:"ANDL\t[$]1023"
// amd64:"ANDL\t[$]1023"
// arm64:"AND\t[$]1023",-"SDIV"
// arm/6:"AND",-".*udiv"
// arm/7:"BFC",-".*udiv",-"AND"
// 386:"ANDL [$]1023"
// amd64:"ANDL [$]1023"
// arm64:"AND [$]1023" -"SDIV"
// arm/6:"AND" -".*udiv"
// arm/7:"BFC" -".*udiv" -"AND"
// ppc64x:"RLDICL"
return len(a) % 1024
}
func LenMod2(s string) int {
// 386:"ANDL\t[$]2047"
// amd64:"ANDL\t[$]2047"
// arm64:"AND\t[$]2047",-"SDIV"
// arm/6:"AND",-".*udiv"
// arm/7:"BFC",-".*udiv",-"AND"
// 386:"ANDL [$]2047"
// amd64:"ANDL [$]2047"
// arm64:"AND [$]2047" -"SDIV"
// arm/6:"AND" -".*udiv"
// arm/7:"BFC" -".*udiv" -"AND"
// ppc64x:"RLDICL"
return len(s) % (4097 >> 1)
}
func CapDiv(a []int) int {
// 386:"SHRL\t[$]12"
// amd64:"SHRQ\t[$]12"
// arm64:"LSR\t[$]12",-"SDIV"
// arm:"SRL\t[$]12",-".*udiv"
// ppc64x:"SRD\t[$]12"
// 386:"SHRL [$]12"
// amd64:"SHRQ [$]12"
// arm64:"LSR [$]12" -"SDIV"
// arm:"SRL [$]12" -".*udiv"
// ppc64x:"SRD [$]12"
return cap(a) / ((1 << 11) + 2048)
}
func CapMod(a []int) int {
// 386:"ANDL\t[$]4095"
// amd64:"ANDL\t[$]4095"
// arm64:"AND\t[$]4095",-"SDIV"
// arm/6:"AND",-".*udiv"
// arm/7:"BFC",-".*udiv",-"AND"
// 386:"ANDL [$]4095"
// amd64:"ANDL [$]4095"
// arm64:"AND [$]4095" -"SDIV"
// arm/6:"AND" -".*udiv"
// arm/7:"BFC" -".*udiv" -"AND"
// ppc64x:"RLDICL"
return cap(a) % ((1 << 11) + 2048)
}
func AddMul(x int) int {
// amd64:"LEAQ\t1"
// amd64:"LEAQ 1"
return 2*x + 1
}
@ -675,29 +671,30 @@ func addSpecial(a, b, c uint32) (uint32, uint32, uint32) {
}
// Divide -> shift rules usually require fixup for negative inputs.
// If the input is non-negative, make sure the fixup is eliminated.
// If the input is non-negative, make sure the unsigned form is generated.
func divInt(v int64) int64 {
if v < 0 {
return 0
// amd64:`SARQ.*63,`, `SHRQ.*56,`, `SARQ.*8,`
return v / 256
}
// amd64:-`.*SARQ.*63,`, -".*SHRQ", ".*SARQ.*[$]9,"
// amd64:-`.*SARQ`, `SHRQ.*9,`
return v / 512
}
// The reassociate rules "x - (z + C) -> (x - z) - C" and
// "(z + C) -x -> C + (z - x)" can optimize the following cases.
func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) {
// arm64:"SUB","ADD\t[$]2"
// ppc64x:"SUB","ADD\t[$]2"
// arm64:"SUB" "ADD [$]2"
// ppc64x:"SUB" "ADD [$]2"
r0 := (i0 + 3) - (j0 + 1)
// arm64:"SUB","SUB\t[$]4"
// ppc64x:"SUB","ADD\t[$]-4"
// arm64:"SUB" "SUB [$]4"
// ppc64x:"SUB" "ADD [$]-4"
r1 := (i1 - 3) - (j1 + 1)
// arm64:"SUB","ADD\t[$]4"
// ppc64x:"SUB","ADD\t[$]4"
// arm64:"SUB" "ADD [$]4"
// ppc64x:"SUB" "ADD [$]4"
r2 := (i2 + 3) - (j2 - 1)
// arm64:"SUB","SUB\t[$]2"
// ppc64x:"SUB","ADD\t[$]-2"
// arm64:"SUB" "SUB [$]2"
// ppc64x:"SUB" "ADD [$]-2"
r3 := (i3 - 3) - (j3 - 1)
return r0, r1, r2, r3
}
@ -705,53 +702,51 @@ func constantFold1(i0, j0, i1, j1, i2, j2, i3, j3 int) (int, int, int, int) {
// The reassociate rules "x - (z + C) -> (x - z) - C" and
// "(C - z) - x -> C - (z + x)" can optimize the following cases.
func constantFold2(i0, j0, i1, j1 int) (int, int) {
// arm64:"ADD","MOVD\t[$]2","SUB"
// ppc64x: `SUBC\tR[0-9]+,\s[$]2,\sR`
// arm64:"ADD" "MOVD [$]2" "SUB"
// ppc64x: `SUBC R[0-9]+,\s[$]2,\sR`
r0 := (3 - i0) - (j0 + 1)
// arm64:"ADD","MOVD\t[$]4","SUB"
// ppc64x: `SUBC\tR[0-9]+,\s[$]4,\sR`
// arm64:"ADD" "MOVD [$]4" "SUB"
// ppc64x: `SUBC R[0-9]+,\s[$]4,\sR`
r1 := (3 - i1) - (j1 - 1)
return r0, r1
}
func constantFold3(i, j int) int {
// arm64: "LSL\t[$]5,","SUB\tR[0-9]+<<1,",-"ADD"
// ppc64x:"MULLD\t[$]30","MULLD"
// arm64: "LSL [$]5," "SUB R[0-9]+<<1," -"ADD"
// ppc64x:"MULLD [$]30" "MULLD"
r := (5 * i) * (6 * j)
return r
}
// ----------------- //
// Integer Min/Max //
// ----------------- //
// Integer Min/Max
func Int64Min(a, b int64) int64 {
// amd64: "CMPQ","CMOVQLT"
// arm64: "CMP","CSEL"
// riscv64/rva20u64:"BLT\t"
// riscv64/rva22u64,riscv64/rva23u64:"MIN\t"
// amd64: "CMPQ" "CMOVQLT"
// arm64: "CMP" "CSEL"
// riscv64/rva20u64:"BLT "
// riscv64/rva22u64,riscv64/rva23u64:"MIN "
return min(a, b)
}
func Int64Max(a, b int64) int64 {
// amd64: "CMPQ","CMOVQGT"
// arm64: "CMP","CSEL"
// riscv64/rva20u64:"BLT\t"
// riscv64/rva22u64,riscv64/rva23u64:"MAX\t"
// amd64: "CMPQ" "CMOVQGT"
// arm64: "CMP" "CSEL"
// riscv64/rva20u64:"BLT "
// riscv64/rva22u64,riscv64/rva23u64:"MAX "
return max(a, b)
}
func Uint64Min(a, b uint64) uint64 {
// amd64: "CMPQ","CMOVQCS"
// arm64: "CMP","CSEL"
// amd64: "CMPQ" "CMOVQCS"
// arm64: "CMP" "CSEL"
// riscv64/rva20u64:"BLTU"
// riscv64/rva22u64,riscv64/rva23u64:"MINU"
return min(a, b)
}
func Uint64Max(a, b uint64) uint64 {
// amd64: "CMPQ","CMOVQHI"
// arm64: "CMP","CSEL"
// amd64: "CMPQ" "CMOVQHI"
// arm64: "CMP" "CSEL"
// riscv64/rva20u64:"BLTU"
// riscv64/rva22u64,riscv64/rva23u64:"MAXU"
return max(a, b)

18
test/codegen/atomics.go
View file

@ -22,7 +22,7 @@ func (c *Counter) Increment() {
// arm64/v8.1:"LDADDALW"
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
// amd64:"LOCK",-"CMPXCHG"
// amd64:"LOCK" -"CMPXCHG"
atomic.AddInt32(&c.count, 1)
}
@ -34,13 +34,13 @@ func atomicLogical64(x *atomic.Uint64) uint64 {
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
// On amd64, make sure we use LOCK+AND instead of CMPXCHG when we don't use the result.
// amd64:"LOCK",-"CMPXCHGQ"
// amd64:"LOCK" -"CMPXCHGQ"
x.And(11)
// arm64/v8.0:"LDCLRALD"
// arm64/v8.1:"LDCLRALD"
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
// amd64:"LOCK","CMPXCHGQ"
// amd64:"LOCK" "CMPXCHGQ"
r += x.And(22)
// arm64/v8.0:"LDORALD"
@ -48,13 +48,13 @@ func atomicLogical64(x *atomic.Uint64) uint64 {
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
// On amd64, make sure we use LOCK+OR instead of CMPXCHG when we don't use the result.
// amd64:"LOCK",-"CMPXCHGQ"
// amd64:"LOCK" -"CMPXCHGQ"
x.Or(33)
// arm64/v8.0:"LDORALD"
// arm64/v8.1:"LDORALD"
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
// amd64:"LOCK","CMPXCHGQ"
// amd64:"LOCK" "CMPXCHGQ"
r += x.Or(44)
return r
@ -68,13 +68,13 @@ func atomicLogical32(x *atomic.Uint32) uint32 {
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
// On amd64, make sure we use LOCK+AND instead of CMPXCHG when we don't use the result.
// amd64:"LOCK",-"CMPXCHGL"
// amd64:"LOCK" -"CMPXCHGL"
x.And(11)
// arm64/v8.0:"LDCLRALW"
// arm64/v8.1:"LDCLRALW"
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
// amd64:"LOCK","CMPXCHGL"
// amd64:"LOCK" "CMPXCHGL"
r += x.And(22)
// arm64/v8.0:"LDORALW"
@ -82,13 +82,13 @@ func atomicLogical32(x *atomic.Uint32) uint32 {
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
// On amd64, make sure we use LOCK+OR instead of CMPXCHG when we don't use the result.
// amd64:"LOCK",-"CMPXCHGL"
// amd64:"LOCK" -"CMPXCHGL"
x.Or(33)
// arm64/v8.0:"LDORALW"
// arm64/v8.1:"LDORALW"
// arm64/v8.0:".*arm64HasATOMICS"
// arm64/v8.1:-".*arm64HasATOMICS"
// amd64:"LOCK","CMPXCHGL"
// amd64:"LOCK" "CMPXCHGL"
r += x.Or(44)
return r

176
test/codegen/bitfield.go
View file

@ -10,304 +10,304 @@ package codegen
// insertion/extraction simplifications/optimizations.
func extr1(x, x2 uint64) uint64 {
return x<<7 + x2>>57 // arm64:"EXTR\t[$]57,"
return x<<7 + x2>>57 // arm64:"EXTR [$]57,"
}
func extr2(x, x2 uint64) uint64 {
return x<<7 | x2>>57 // arm64:"EXTR\t[$]57,"
return x<<7 | x2>>57 // arm64:"EXTR [$]57,"
}
func extr3(x, x2 uint64) uint64 {
return x<<7 ^ x2>>57 // arm64:"EXTR\t[$]57,"
return x<<7 ^ x2>>57 // arm64:"EXTR [$]57,"
}
func extr4(x, x2 uint32) uint32 {
return x<<7 + x2>>25 // arm64:"EXTRW\t[$]25,"
return x<<7 + x2>>25 // arm64:"EXTRW [$]25,"
}
func extr5(x, x2 uint32) uint32 {
return x<<7 | x2>>25 // arm64:"EXTRW\t[$]25,"
return x<<7 | x2>>25 // arm64:"EXTRW [$]25,"
}
func extr6(x, x2 uint32) uint32 {
return x<<7 ^ x2>>25 // arm64:"EXTRW\t[$]25,"
return x<<7 ^ x2>>25 // arm64:"EXTRW [$]25,"
}
// check 32-bit shift masking
func mask32(x uint32) uint32 {
return (x << 29) >> 29 // arm64:"AND\t[$]7, R[0-9]+",-"LSR",-"LSL"
return (x << 29) >> 29 // arm64:"AND [$]7, R[0-9]+" -"LSR" -"LSL"
}
// check 16-bit shift masking
func mask16(x uint16) uint16 {
return (x << 14) >> 14 // arm64:"AND\t[$]3, R[0-9]+",-"LSR",-"LSL"
return (x << 14) >> 14 // arm64:"AND [$]3, R[0-9]+" -"LSR" -"LSL"
}
// check 8-bit shift masking
func mask8(x uint8) uint8 {
return (x << 7) >> 7 // arm64:"AND\t[$]1, R[0-9]+",-"LSR",-"LSL"
return (x << 7) >> 7 // arm64:"AND [$]1, R[0-9]+" -"LSR" -"LSL"
}
func maskshift(x uint64) uint64 {
// arm64:"AND\t[$]4095, R[0-9]+",-"LSL",-"LSR",-"UBFIZ",-"UBFX"
// arm64:"AND [$]4095, R[0-9]+" -"LSL" -"LSR" -"UBFIZ" -"UBFX"
return ((x << 5) & (0xfff << 5)) >> 5
}
// bitfield ops
// bfi
func bfi1(x, y uint64) uint64 {
// arm64:"BFI\t[$]4, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND"
// arm64:"BFI [$]4, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND"
return ((x & 0xfff) << 4) | (y & 0xffffffffffff000f)
}
func bfi2(x, y uint64) uint64 {
// arm64:"BFI\t[$]12, R[0-9]+, [$]40",-"LSL",-"LSR",-"AND"
// arm64:"BFI [$]12, R[0-9]+, [$]40" -"LSL" -"LSR" -"AND"
return (x << 24 >> 12) | (y & 0xfff0000000000fff)
}
// bfxil
func bfxil1(x, y uint64) uint64 {
// arm64:"BFXIL\t[$]5, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND"
// arm64:"BFXIL [$]5, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND"
return ((x >> 5) & 0xfff) | (y & 0xfffffffffffff000)
}
func bfxil2(x, y uint64) uint64 {
// arm64:"BFXIL\t[$]12, R[0-9]+, [$]40",-"LSL",-"LSR",-"AND"
// arm64:"BFXIL [$]12, R[0-9]+, [$]40" -"LSL" -"LSR" -"AND"
return (x << 12 >> 24) | (y & 0xffffff0000000000)
}
// sbfiz
// merge shifts into sbfiz: (x << lc) >> rc && lc > rc.
func sbfiz1(x int64) int64 {
// arm64:"SBFIZ\t[$]1, R[0-9]+, [$]60",-"LSL",-"ASR"
// arm64:"SBFIZ [$]1, R[0-9]+, [$]60" -"LSL" -"ASR"
return (x << 4) >> 3
}
// merge shift and sign-extension into sbfiz.
func sbfiz2(x int32) int64 {
return int64(x << 3) // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]29",-"LSL"
return int64(x << 3) // arm64:"SBFIZ [$]3, R[0-9]+, [$]29" -"LSL"
}
func sbfiz3(x int16) int64 {
return int64(x << 3) // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]13",-"LSL"
return int64(x << 3) // arm64:"SBFIZ [$]3, R[0-9]+, [$]13" -"LSL"
}
func sbfiz4(x int8) int64 {
return int64(x << 3) // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]5",-"LSL"
return int64(x << 3) // arm64:"SBFIZ [$]3, R[0-9]+, [$]5" -"LSL"
}
// sbfiz combinations.
// merge shift with sbfiz into sbfiz.
func sbfiz5(x int32) int32 {
// arm64:"SBFIZ\t[$]1, R[0-9]+, [$]28",-"LSL",-"ASR"
// arm64:"SBFIZ [$]1, R[0-9]+, [$]28" -"LSL" -"ASR"
return (x << 4) >> 3
}
func sbfiz6(x int16) int64 {
return int64(x+1) << 3 // arm64:"SBFIZ\t[$]3, R[0-9]+, [$]16",-"LSL"
return int64(x+1) << 3 // arm64:"SBFIZ [$]3, R[0-9]+, [$]16" -"LSL"
}
func sbfiz7(x int8) int64 {
return int64(x+1) << 62 // arm64:"SBFIZ\t[$]62, R[0-9]+, [$]2",-"LSL"
return int64(x+1) << 62 // arm64:"SBFIZ [$]62, R[0-9]+, [$]2" -"LSL"
}
func sbfiz8(x int32) int64 {
return int64(x+1) << 40 // arm64:"SBFIZ\t[$]40, R[0-9]+, [$]24",-"LSL"
return int64(x+1) << 40 // arm64:"SBFIZ [$]40, R[0-9]+, [$]24" -"LSL"
}
// sbfx
// merge shifts into sbfx: (x << lc) >> rc && lc <= rc.
func sbfx1(x int64) int64 {
return (x << 3) >> 4 // arm64:"SBFX\t[$]1, R[0-9]+, [$]60",-"LSL",-"ASR"
return (x << 3) >> 4 // arm64:"SBFX [$]1, R[0-9]+, [$]60" -"LSL" -"ASR"
}
func sbfx2(x int64) int64 {
return (x << 60) >> 60 // arm64:"SBFX\t[$]0, R[0-9]+, [$]4",-"LSL",-"ASR"
return (x << 60) >> 60 // arm64:"SBFX [$]0, R[0-9]+, [$]4" -"LSL" -"ASR"
}
// merge shift and sign-extension into sbfx.
func sbfx3(x int32) int64 {
return int64(x) >> 3 // arm64:"SBFX\t[$]3, R[0-9]+, [$]29",-"ASR"
return int64(x) >> 3 // arm64:"SBFX [$]3, R[0-9]+, [$]29" -"ASR"
}
func sbfx4(x int16) int64 {
return int64(x) >> 3 // arm64:"SBFX\t[$]3, R[0-9]+, [$]13",-"ASR"
return int64(x) >> 3 // arm64:"SBFX [$]3, R[0-9]+, [$]13" -"ASR"
}
func sbfx5(x int8) int64 {
return int64(x) >> 3 // arm64:"SBFX\t[$]3, R[0-9]+, [$]5",-"ASR"
return int64(x) >> 3 // arm64:"SBFX [$]3, R[0-9]+, [$]5" -"ASR"
}
func sbfx6(x int32) int64 {
return int64(x >> 30) // arm64:"SBFX\t[$]30, R[0-9]+, [$]2"
return int64(x >> 30) // arm64:"SBFX [$]30, R[0-9]+, [$]2"
}
func sbfx7(x int16) int64 {
return int64(x >> 10) // arm64:"SBFX\t[$]10, R[0-9]+, [$]6"
return int64(x >> 10) // arm64:"SBFX [$]10, R[0-9]+, [$]6"
}
func sbfx8(x int8) int64 {
return int64(x >> 5) // arm64:"SBFX\t[$]5, R[0-9]+, [$]3"
return int64(x >> 5) // arm64:"SBFX [$]5, R[0-9]+, [$]3"
}
// sbfx combinations.
// merge shifts with sbfiz into sbfx.
func sbfx9(x int32) int32 {
return (x << 3) >> 4 // arm64:"SBFX\t[$]1, R[0-9]+, [$]28",-"LSL",-"ASR"
return (x << 3) >> 4 // arm64:"SBFX [$]1, R[0-9]+, [$]28" -"LSL" -"ASR"
}
// merge sbfx and sign-extension into sbfx.
func sbfx10(x int32) int64 {
c := x + 5
return int64(c >> 20) // arm64"SBFX\t[$]20, R[0-9]+, [$]12",-"MOVW\tR[0-9]+, R[0-9]+"
return int64(c >> 20) // arm64"SBFX [$]20, R[0-9]+, [$]12" -"MOVW R[0-9]+, R[0-9]+"
}
// ubfiz
// merge shifts into ubfiz: (x<<lc)>>rc && lc>rc
func ubfiz1(x uint64) uint64 {
// arm64:"UBFIZ\t[$]1, R[0-9]+, [$]60",-"LSL",-"LSR"
// s390x:"RISBGZ\t[$]3, [$]62, [$]1, ",-"SLD",-"SRD"
// arm64:"UBFIZ [$]1, R[0-9]+, [$]60" -"LSL" -"LSR"
// s390x:"RISBGZ [$]3, [$]62, [$]1, " -"SLD" -"SRD"
return (x << 4) >> 3
}
// merge shift and zero-extension into ubfiz.
func ubfiz2(x uint32) uint64 {
return uint64(x+1) << 3 // arm64:"UBFIZ\t[$]3, R[0-9]+, [$]32",-"LSL"
return uint64(x+1) << 3 // arm64:"UBFIZ [$]3, R[0-9]+, [$]32" -"LSL"
}
func ubfiz3(x uint16) uint64 {
return uint64(x+1) << 3 // arm64:"UBFIZ\t[$]3, R[0-9]+, [$]16",-"LSL"
return uint64(x+1) << 3 // arm64:"UBFIZ [$]3, R[0-9]+, [$]16" -"LSL"
}
func ubfiz4(x uint8) uint64 {
return uint64(x+1) << 3 // arm64:"UBFIZ\t[$]3, R[0-9]+, [$]8",-"LSL"
return uint64(x+1) << 3 // arm64:"UBFIZ [$]3, R[0-9]+, [$]8" -"LSL"
}
func ubfiz5(x uint8) uint64 {
return uint64(x) << 60 // arm64:"UBFIZ\t[$]60, R[0-9]+, [$]4",-"LSL"
return uint64(x) << 60 // arm64:"UBFIZ [$]60, R[0-9]+, [$]4" -"LSL"
}
func ubfiz6(x uint32) uint64 {
return uint64(x << 30) // arm64:"UBFIZ\t[$]30, R[0-9]+, [$]2",
return uint64(x << 30) // arm64:"UBFIZ [$]30, R[0-9]+, [$]2",
}
func ubfiz7(x uint16) uint64 {
return uint64(x << 10) // arm64:"UBFIZ\t[$]10, R[0-9]+, [$]6",
return uint64(x << 10) // arm64:"UBFIZ [$]10, R[0-9]+, [$]6",
}
func ubfiz8(x uint8) uint64 {
return uint64(x << 7) // arm64:"UBFIZ\t[$]7, R[0-9]+, [$]1",
return uint64(x << 7) // arm64:"UBFIZ [$]7, R[0-9]+, [$]1",
}
// merge ANDconst into ubfiz.
func ubfiz9(x uint64) uint64 {
// arm64:"UBFIZ\t[$]3, R[0-9]+, [$]12",-"LSL",-"AND"
// s390x:"RISBGZ\t[$]49, [$]60, [$]3,",-"SLD",-"AND"
// arm64:"UBFIZ [$]3, R[0-9]+, [$]12" -"LSL" -"AND"
// s390x:"RISBGZ [$]49, [$]60, [$]3," -"SLD" -"AND"
return (x & 0xfff) << 3
}
func ubfiz10(x uint64) uint64 {
// arm64:"UBFIZ\t[$]4, R[0-9]+, [$]12",-"LSL",-"AND"
// s390x:"RISBGZ\t[$]48, [$]59, [$]4,",-"SLD",-"AND"
// arm64:"UBFIZ [$]4, R[0-9]+, [$]12" -"LSL" -"AND"
// s390x:"RISBGZ [$]48, [$]59, [$]4," -"SLD" -"AND"
return (x << 4) & 0xfff0
}
// ubfiz combinations
func ubfiz11(x uint32) uint32 {
// arm64:"UBFIZ\t[$]1, R[0-9]+, [$]28",-"LSL",-"LSR"
// arm64:"UBFIZ [$]1, R[0-9]+, [$]28" -"LSL" -"LSR"
return (x << 4) >> 3
}
func ubfiz12(x uint64) uint64 {
// arm64:"UBFIZ\t[$]1, R[0-9]+, [$]20",-"LSL",-"LSR"
// s390x:"RISBGZ\t[$]43, [$]62, [$]1, ",-"SLD",-"SRD",-"AND"
// arm64:"UBFIZ [$]1, R[0-9]+, [$]20" -"LSL" -"LSR"
// s390x:"RISBGZ [$]43, [$]62, [$]1, " -"SLD" -"SRD" -"AND"
return ((x & 0xfffff) << 4) >> 3
}
func ubfiz13(x uint64) uint64 {
// arm64:"UBFIZ\t[$]5, R[0-9]+, [$]13",-"LSL",-"LSR",-"AND"
// arm64:"UBFIZ [$]5, R[0-9]+, [$]13" -"LSL" -"LSR" -"AND"
return ((x << 3) & 0xffff) << 2
}
func ubfiz14(x uint64) uint64 {
// arm64:"UBFIZ\t[$]7, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND"
// s390x:"RISBGZ\t[$]45, [$]56, [$]7, ",-"SLD",-"SRD",-"AND"
// arm64:"UBFIZ [$]7, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND"
// s390x:"RISBGZ [$]45, [$]56, [$]7, " -"SLD" -"SRD" -"AND"
return ((x << 5) & (0xfff << 5)) << 2
}
// ubfx
// merge shifts into ubfx: (x<<lc)>>rc && lc<rc
func ubfx1(x uint64) uint64 {
// arm64:"UBFX\t[$]1, R[0-9]+, [$]62",-"LSL",-"LSR"
// s390x:"RISBGZ\t[$]2, [$]63, [$]63,",-"SLD",-"SRD"
// arm64:"UBFX [$]1, R[0-9]+, [$]62" -"LSL" -"LSR"
// s390x:"RISBGZ [$]2, [$]63, [$]63," -"SLD" -"SRD"
return (x << 1) >> 2
}
// merge shift and zero-extension into ubfx.
func ubfx2(x uint32) uint64 {
return uint64(x >> 15) // arm64:"UBFX\t[$]15, R[0-9]+, [$]17",-"LSR"
return uint64(x >> 15) // arm64:"UBFX [$]15, R[0-9]+, [$]17" -"LSR"
}
func ubfx3(x uint16) uint64 {
return uint64(x >> 9) // arm64:"UBFX\t[$]9, R[0-9]+, [$]7",-"LSR"
return uint64(x >> 9) // arm64:"UBFX [$]9, R[0-9]+, [$]7" -"LSR"
}
func ubfx4(x uint8) uint64 {
return uint64(x >> 3) // arm64:"UBFX\t[$]3, R[0-9]+, [$]5",-"LSR"
return uint64(x >> 3) // arm64:"UBFX [$]3, R[0-9]+, [$]5" -"LSR"
}
func ubfx5(x uint32) uint64 {
return uint64(x) >> 30 // arm64:"UBFX\t[$]30, R[0-9]+, [$]2"
return uint64(x) >> 30 // arm64:"UBFX [$]30, R[0-9]+, [$]2"
}
func ubfx6(x uint16) uint64 {
return uint64(x) >> 10 // arm64:"UBFX\t[$]10, R[0-9]+, [$]6"
return uint64(x) >> 10 // arm64:"UBFX [$]10, R[0-9]+, [$]6"
}
func ubfx7(x uint8) uint64 {
return uint64(x) >> 3 // arm64:"UBFX\t[$]3, R[0-9]+, [$]5"
return uint64(x) >> 3 // arm64:"UBFX [$]3, R[0-9]+, [$]5"
}
// merge ANDconst into ubfx.
func ubfx8(x uint64) uint64 {
// arm64:"UBFX\t[$]25, R[0-9]+, [$]10",-"LSR",-"AND"
// s390x:"RISBGZ\t[$]54, [$]63, [$]39, ",-"SRD",-"AND"
// arm64:"UBFX [$]25, R[0-9]+, [$]10" -"LSR" -"AND"
// s390x:"RISBGZ [$]54, [$]63, [$]39, " -"SRD" -"AND"
return (x >> 25) & 1023
}
func ubfx9(x uint64) uint64 {
// arm64:"UBFX\t[$]4, R[0-9]+, [$]8",-"LSR",-"AND"
// s390x:"RISBGZ\t[$]56, [$]63, [$]60, ",-"SRD",-"AND"
// arm64:"UBFX [$]4, R[0-9]+, [$]8" -"LSR" -"AND"
// s390x:"RISBGZ [$]56, [$]63, [$]60, " -"SRD" -"AND"
return (x & 0x0ff0) >> 4
}
// ubfx combinations.
func ubfx10(x uint32) uint32 {
// arm64:"UBFX\t[$]1, R[0-9]+, [$]30",-"LSL",-"LSR"
// arm64:"UBFX [$]1, R[0-9]+, [$]30" -"LSL" -"LSR"
return (x << 1) >> 2
}
func ubfx11(x uint64) uint64 {
// arm64:"UBFX\t[$]1, R[0-9]+, [$]12",-"LSL",-"LSR",-"AND"
// s390x:"RISBGZ\t[$]52, [$]63, [$]63,",-"SLD",-"SRD",-"AND"
// arm64:"UBFX [$]1, R[0-9]+, [$]12" -"LSL" -"LSR" -"AND"
// s390x:"RISBGZ [$]52, [$]63, [$]63," -"SLD" -"SRD" -"AND"
return ((x << 1) >> 2) & 0xfff
}
func ubfx12(x uint64) uint64 {
// arm64:"UBFX\t[$]4, R[0-9]+, [$]11",-"LSL",-"LSR",-"AND"
// s390x:"RISBGZ\t[$]53, [$]63, [$]60, ",-"SLD",-"SRD",-"AND"
// arm64:"UBFX [$]4, R[0-9]+, [$]11" -"LSL" -"LSR" -"AND"
// s390x:"RISBGZ [$]53, [$]63, [$]60, " -"SLD" -"SRD" -"AND"
return ((x >> 3) & 0xfff) >> 1
}
func ubfx13(x uint64) uint64 {
// arm64:"UBFX\t[$]5, R[0-9]+, [$]56",-"LSL",-"LSR"
// s390x:"RISBGZ\t[$]8, [$]63, [$]59, ",-"SLD",-"SRD"
// arm64:"UBFX [$]5, R[0-9]+, [$]56" -"LSL" -"LSR"
// s390x:"RISBGZ [$]8, [$]63, [$]59, " -"SLD" -"SRD"
return ((x >> 2) << 5) >> 8
}
func ubfx14(x uint64) uint64 {
// arm64:"UBFX\t[$]1, R[0-9]+, [$]19",-"LSL",-"LSR"
// s390x:"RISBGZ\t[$]45, [$]63, [$]63, ",-"SLD",-"SRD",-"AND"
// arm64:"UBFX [$]1, R[0-9]+, [$]19" -"LSL" -"LSR"
// s390x:"RISBGZ [$]45, [$]63, [$]63, " -"SLD" -"SRD" -"AND"
return ((x & 0xfffff) << 3) >> 4
}
@ -315,7 +315,7 @@ func ubfx14(x uint64) uint64 {
func ubfx15(x uint64) bool {
midr := x + 10
part_num := uint16((midr >> 4) & 0xfff)
if part_num == 0xd0c { // arm64:"UBFX\t[$]4, R[0-9]+, [$]12",-"MOVHU\tR[0-9]+, R[0-9]+"
if part_num == 0xd0c { // arm64:"UBFX [$]4, R[0-9]+, [$]12" -"MOVHU R[0-9]+, R[0-9]+"
return true
}
return false
@ -323,7 +323,7 @@ func ubfx15(x uint64) bool {
// merge ANDconst and ubfx into ubfx
func ubfx16(x uint64) uint64 {
// arm64:"UBFX\t[$]4, R[0-9]+, [$]6",-"AND\t[$]63"
// arm64:"UBFX [$]4, R[0-9]+, [$]6" -"AND [$]63"
return ((x >> 3) & 0xfff) >> 1 & 0x3f
}
@ -331,48 +331,48 @@ func ubfx16(x uint64) uint64 {
//
//go:nosplit
func shift_no_cmp(x int) int {
// arm64:`LSL\t[$]17`,-`CMP`
// mips64:`SLLV\t[$]17`,-`SGT`
// arm64:`LSL [$]17`,-`CMP`
// mips64:`SLLV [$]17`,-`SGT`
return x << 17
}
func rev16(c uint64) (uint64, uint64, uint64) {
// arm64:`REV16`,-`AND`,-`LSR`,-`AND`,-`ORR\tR[0-9]+<<8`
// arm64:`REV16`,-`AND`,-`LSR`,-`AND`,-`ORR R[0-9]+<<8`
// loong64:`REVB4H`,-`MOVV`,-`AND`,-`SRLV`,-`AND`,-`SLLV`,-`OR`
b1 := ((c & 0xff00ff00ff00ff00) >> 8) | ((c & 0x00ff00ff00ff00ff) << 8)
// arm64:-`ADD\tR[0-9]+<<8`
// arm64:-`ADD R[0-9]+<<8`
// loong64:-`ADDV`
b2 := ((c & 0xff00ff00ff00ff00) >> 8) + ((c & 0x00ff00ff00ff00ff) << 8)
// arm64:-`EOR\tR[0-9]+<<8`
// arm64:-`EOR R[0-9]+<<8`
// loong64:-`XOR`
b3 := ((c & 0xff00ff00ff00ff00) >> 8) ^ ((c & 0x00ff00ff00ff00ff) << 8)
return b1, b2, b3
}
func rev16w(c uint32) (uint32, uint32, uint32) {
// arm64:`REV16W`,-`AND`,-`UBFX`,-`AND`,-`ORR\tR[0-9]+<<8`
// arm64:`REV16W`,-`AND`,-`UBFX`,-`AND`,-`ORR R[0-9]+<<8`
// loong64:`REVB2H`,-`AND`,-`SRL`,-`AND`,-`SLL`,-`OR`
b1 := ((c & 0xff00ff00) >> 8) | ((c & 0x00ff00ff) << 8)
// arm64:-`ADD\tR[0-9]+<<8`
// arm64:-`ADD R[0-9]+<<8`
// loong64:-`ADDV`
b2 := ((c & 0xff00ff00) >> 8) + ((c & 0x00ff00ff) << 8)
// arm64:-`EOR\tR[0-9]+<<8`
// arm64:-`EOR R[0-9]+<<8`
// loong64:-`XOR`
b3 := ((c & 0xff00ff00) >> 8) ^ ((c & 0x00ff00ff) << 8)
return b1, b2, b3
}
func shift(x uint32, y uint16, z uint8) uint64 {
// arm64:-`MOVWU`,-`LSR\t[$]32`
// loong64:-`MOVWU`,-`SRLV\t[$]32`
// arm64:-`MOVWU`,-`LSR [$]32`
// loong64:-`MOVWU`,-`SRLV [$]32`
a := uint64(x) >> 32
// arm64:-`MOVHU
// loong64:-`MOVHU`,-`SRLV\t[$]16`
// loong64:-`MOVHU`,-`SRLV [$]16`
b := uint64(y) >> 16
// arm64:-`MOVBU`
// loong64:-`MOVBU`,-`SRLV\t[$]8`
// loong64:-`MOVBU`,-`SRLV [$]8`
c := uint64(z) >> 8
// arm64:`MOVD\tZR`,-`ADD\tR[0-9]+>>16`,-`ADD\tR[0-9]+>>8`,
// loong64:`MOVV\tR0`,-`ADDVU`
// arm64:`MOVD ZR`,-`ADD R[0-9]+>>16`,-`ADD R[0-9]+>>8`,
// loong64:`MOVV R0`,-`ADDVU`
return a + b + c
}

164
test/codegen/bits.go
View file

@ -13,15 +13,15 @@ import "math/bits"
************************************/
func bitcheck64_constleft(a uint64) (n int) {
// amd64:"BTQ\t[$]63"
// amd64:"BTQ [$]63"
if a&(1<<63) != 0 {
return 1
}
// amd64:"BTQ\t[$]60"
// amd64:"BTQ [$]60"
if a&(1<<60) != 0 {
return 1
}
// amd64:"BTL\t[$]0"
// amd64:"BTL [$]0"
if a&(1<<0) != 0 {
return 1
}
@ -29,31 +29,31 @@ func bitcheck64_constleft(a uint64) (n int) {
}
func bitcheck64_constright(a [8]uint64) (n int) {
// amd64:"BTQ\t[$]63"
// amd64:"BTQ [$]63"
if (a[0]>>63)&1 != 0 {
return 1
}
// amd64:"BTQ\t[$]63"
// amd64:"BTQ [$]63"
if a[1]>>63 != 0 {
return 1
}
// amd64:"BTQ\t[$]63"
// amd64:"BTQ [$]63"
if a[2]>>63 == 0 {
return 1
}
// amd64:"BTQ\t[$]60"
// amd64:"BTQ [$]60"
if (a[3]>>60)&1 == 0 {
return 1
}
// amd64:"BTL\t[$]1"
// amd64:"BTL [$]1"
if (a[4]>>1)&1 == 0 {
return 1
}
// amd64:"BTL\t[$]0"
// amd64:"BTL [$]0"
if (a[5]>>0)&1 == 0 {
return 1
}
// amd64:"BTL\t[$]7"
// amd64:"BTL [$]7"
if (a[6]>>5)&4 == 0 {
return 1
}
@ -65,7 +65,7 @@ func bitcheck64_var(a, b uint64) (n int) {
if a&(1<<(b&63)) != 0 {
return 1
}
// amd64:"BTQ",-"BT.\t[$]0"
// amd64:"BTQ" -"BT. [$]0"
if (b>>(a&63))&1 != 0 {
return 1
}
@ -73,15 +73,15 @@ func bitcheck64_var(a, b uint64) (n int) {
}
func bitcheck64_mask(a uint64) (n int) {
// amd64:"BTQ\t[$]63"
// amd64:"BTQ [$]63"
if a&0x8000000000000000 != 0 {
return 1
}
// amd64:"BTQ\t[$]59"
// amd64:"BTQ [$]59"
if a&0x800000000000000 != 0 {
return 1
}
// amd64:"BTL\t[$]0"
// amd64:"BTL [$]0"
if a&0x1 != 0 {
return 1
}
@ -92,13 +92,13 @@ func biton64(a, b uint64) (n uint64) {
// amd64:"BTSQ"
n += b | (1 << (a & 63))
// amd64:"BTSQ\t[$]63"
// amd64:"BTSQ [$]63"
n += a | (1 << 63)
// amd64:"BTSQ\t[$]60"
// amd64:"BTSQ [$]60"
n += a | (1 << 60)
// amd64:"ORQ\t[$]1"
// amd64:"ORQ [$]1"
n += a | (1 << 0)
return n
@ -108,23 +108,23 @@ func bitoff64(a, b uint64) (n uint64) {
// amd64:"BTRQ"
n += b &^ (1 << (a & 63))
// amd64:"BTRQ\t[$]63"
// amd64:"BTRQ [$]63"
n += a &^ (1 << 63)
// amd64:"BTRQ\t[$]60"
// amd64:"BTRQ [$]60"
n += a &^ (1 << 60)
// amd64:"ANDQ\t[$]-2"
// amd64:"ANDQ [$]-2"
n += a &^ (1 << 0)
return n
}
func clearLastBit(x int64, y int32) (int64, int32) {
// amd64:"ANDQ\t[$]-2"
// amd64:"ANDQ [$]-2"
a := (x >> 1) << 1
// amd64:"ANDL\t[$]-2"
// amd64:"ANDL [$]-2"
b := (y >> 1) << 1
return a, b
@ -134,13 +134,13 @@ func bitcompl64(a, b uint64) (n uint64) {
// amd64:"BTCQ"
n += b ^ (1 << (a & 63))
// amd64:"BTCQ\t[$]63"
// amd64:"BTCQ [$]63"
n += a ^ (1 << 63)
// amd64:"BTCQ\t[$]60"
// amd64:"BTCQ [$]60"
n += a ^ (1 << 60)
// amd64:"XORQ\t[$]1"
// amd64:"XORQ [$]1"
n += a ^ (1 << 0)
return n
@ -151,15 +151,15 @@ func bitcompl64(a, b uint64) (n uint64) {
************************************/
func bitcheck32_constleft(a uint32) (n int) {
// amd64:"BTL\t[$]31"
// amd64:"BTL [$]31"
if a&(1<<31) != 0 {
return 1
}
// amd64:"BTL\t[$]28"
// amd64:"BTL [$]28"
if a&(1<<28) != 0 {
return 1
}
// amd64:"BTL\t[$]0"
// amd64:"BTL [$]0"
if a&(1<<0) != 0 {
return 1
}
@ -167,31 +167,31 @@ func bitcheck32_constleft(a uint32) (n int) {
}
func bitcheck32_constright(a [8]uint32) (n int) {
// amd64:"BTL\t[$]31"
// amd64:"BTL [$]31"
if (a[0]>>31)&1 != 0 {
return 1
}
// amd64:"BTL\t[$]31"
// amd64:"BTL [$]31"
if a[1]>>31 != 0 {
return 1
}
// amd64:"BTL\t[$]31"
// amd64:"BTL [$]31"
if a[2]>>31 == 0 {
return 1
}
// amd64:"BTL\t[$]28"
// amd64:"BTL [$]28"
if (a[3]>>28)&1 == 0 {
return 1
}
// amd64:"BTL\t[$]1"
// amd64:"BTL [$]1"
if (a[4]>>1)&1 == 0 {
return 1
}
// amd64:"BTL\t[$]0"
// amd64:"BTL [$]0"
if (a[5]>>0)&1 == 0 {
return 1
}
// amd64:"BTL\t[$]7"
// amd64:"BTL [$]7"
if (a[6]>>5)&4 == 0 {
return 1
}
@ -203,7 +203,7 @@ func bitcheck32_var(a, b uint32) (n int) {
if a&(1<<(b&31)) != 0 {
return 1
}
// amd64:"BTL",-"BT.\t[$]0"
// amd64:"BTL" -"BT. [$]0"
if (b>>(a&31))&1 != 0 {
return 1
}
@ -211,15 +211,15 @@ func bitcheck32_var(a, b uint32) (n int) {
}
func bitcheck32_mask(a uint32) (n int) {
// amd64:"BTL\t[$]31"
// amd64:"BTL [$]31"
if a&0x80000000 != 0 {
return 1
}
// amd64:"BTL\t[$]27"
// amd64:"BTL [$]27"
if a&0x8000000 != 0 {
return 1
}
// amd64:"BTL\t[$]0"
// amd64:"BTL [$]0"
if a&0x1 != 0 {
return 1
}
@ -230,13 +230,13 @@ func biton32(a, b uint32) (n uint32) {
// amd64:"BTSL"
n += b | (1 << (a & 31))
// amd64:"ORL\t[$]-2147483648"
// amd64:"ORL [$]-2147483648"
n += a | (1 << 31)
// amd64:"ORL\t[$]268435456"
// amd64:"ORL [$]268435456"
n += a | (1 << 28)
// amd64:"ORL\t[$]1"
// amd64:"ORL [$]1"
n += a | (1 << 0)
return n
@ -246,13 +246,13 @@ func bitoff32(a, b uint32) (n uint32) {
// amd64:"BTRL"
n += b &^ (1 << (a & 31))
// amd64:"ANDL\t[$]2147483647"
// amd64:"ANDL [$]2147483647"
n += a &^ (1 << 31)
// amd64:"ANDL\t[$]-268435457"
// amd64:"ANDL [$]-268435457"
n += a &^ (1 << 28)
// amd64:"ANDL\t[$]-2"
// amd64:"ANDL [$]-2"
n += a &^ (1 << 0)
return n
@ -262,13 +262,13 @@ func bitcompl32(a, b uint32) (n uint32) {
// amd64:"BTCL"
n += b ^ (1 << (a & 31))
// amd64:"XORL\t[$]-2147483648"
// amd64:"XORL [$]-2147483648"
n += a ^ (1 << 31)
// amd64:"XORL\t[$]268435456"
// amd64:"XORL [$]268435456"
n += a ^ (1 << 28)
// amd64:"XORL\t[$]1"
// amd64:"XORL [$]1"
n += a ^ (1 << 0)
return n
@ -292,12 +292,12 @@ func bitcheckMostNegative(b uint8) bool {
// Check AND masking on arm64 (Issue #19857)
func and_mask_1(a uint64) uint64 {
// arm64:`AND\t`
// arm64:`AND `
return a & ((1 << 63) - 1)
}
func and_mask_2(a uint64) uint64 {
// arm64:`AND\t`
// arm64:`AND `
return a & (1 << 63)
}
@ -312,65 +312,65 @@ func and_mask_3(a, b uint32) (uint32, uint32) {
// Check generation of arm64 BIC/EON/ORN instructions
func op_bic(x, y uint32) uint32 {
// arm64:`BIC\t`,-`AND`
// arm64:`BIC `,-`AND`
return x &^ y
}
func op_eon(x, y, z uint32, a []uint32, n, m uint64) uint64 {
// arm64:`EON\t`,-`EOR`,-`MVN`
// arm64:`EON `,-`EOR`,-`MVN`
a[0] = x ^ (y ^ 0xffffffff)
// arm64:`EON\t`,-`EOR`,-`MVN`
// arm64:`EON `,-`EOR`,-`MVN`
a[1] = ^(y ^ z)
// arm64:`EON\t`,-`XOR`
// arm64:`EON `,-`XOR`
a[2] = x ^ ^z
// arm64:`EON\t`,-`EOR`,-`MVN`
// arm64:`EON `,-`EOR`,-`MVN`
return n ^ (m ^ 0xffffffffffffffff)
}
func op_orn(x, y uint32) uint32 {
// arm64:`ORN\t`,-`ORR`
// loong64:"ORN"\t,-"OR\t"
// arm64:`ORN `,-`ORR`
// loong64:"ORN" ,-"OR "
return x | ^y
}
func op_nor(x int64, a []int64) {
// loong64: "MOVV\t[$]0","NOR\tR"
// loong64: "MOVV [$]0" "NOR R"
a[0] = ^(0x1234 | x)
// loong64:"NOR",-"XOR"
// loong64:"NOR" -"XOR"
a[1] = (-1) ^ x
// loong64: "MOVV\t[$]-55",-"OR",-"NOR"
// loong64: "MOVV [$]-55" -"OR" -"NOR"
a[2] = ^(0x12 | 0x34)
}
func op_andn(x, y uint32) uint32 {
// loong64:"ANDN\t",-"AND\t"
// loong64:"ANDN " -"AND "
return x &^ y
}
// check bitsets
func bitSetPowerOf2Test(x int) bool {
// amd64:"BTL\t[$]3"
// amd64:"BTL [$]3"
return x&8 == 8
}
func bitSetTest(x int) bool {
// amd64:"ANDL\t[$]9, AX"
// amd64:"CMPQ\tAX, [$]9"
// amd64:"ANDL [$]9, AX"
// amd64:"CMPQ AX, [$]9"
return x&9 == 9
}
// mask contiguous one bits
func cont1Mask64U(x uint64) uint64 {
// s390x:"RISBGZ\t[$]16, [$]47, [$]0,"
// s390x:"RISBGZ [$]16, [$]47, [$]0,"
return x & 0x0000ffffffff0000
}
// mask contiguous zero bits
func cont0Mask64U(x uint64) uint64 {
// s390x:"RISBGZ\t[$]48, [$]15, [$]0,"
// s390x:"RISBGZ [$]48, [$]15, [$]0,"
return x & 0xffff00000000ffff
}
@ -390,60 +390,60 @@ func issue48467(x, y uint64) uint64 {
}
func foldConst(x, y uint64) uint64 {
// arm64: "ADDS\t[$]7",-"MOVD\t[$]7"
// ppc64x: "ADDC\t[$]7,"
// arm64: "ADDS [$]7" -"MOVD [$]7"
// ppc64x: "ADDC [$]7,"
d, b := bits.Add64(x, 7, 0)
return b & d
}
func foldConstOutOfRange(a uint64) uint64 {
// arm64: "MOVD\t[$]19088744",-"ADD\t[$]19088744"
// arm64: "MOVD [$]19088744" -"ADD [$]19088744"
return a + 0x1234568
}
// Verify sign-extended values are not zero-extended under a bit mask (#61297)
func signextendAndMask8to64(a int8) (s, z uint64) {
// ppc64x: "MOVB", "ANDCC\t[$]1015,"
// ppc64x: "MOVB", "ANDCC [$]1015,"
s = uint64(a) & 0x3F7
// ppc64x: -"MOVB", "ANDCC\t[$]247,"
// ppc64x: -"MOVB", "ANDCC [$]247,"
z = uint64(uint8(a)) & 0x3F7
return
}
// Verify zero-extended values are not sign-extended under a bit mask (#61297)
func zeroextendAndMask8to64(a int8, b int16) (x, y uint64) {
// ppc64x: -"MOVB\t", -"ANDCC", "MOVBZ"
// ppc64x: -"MOVB ", -"ANDCC", "MOVBZ"
x = uint64(a) & 0xFF
// ppc64x: -"MOVH\t", -"ANDCC", "MOVHZ"
// ppc64x: -"MOVH ", -"ANDCC", "MOVHZ"
y = uint64(b) & 0xFFFF
return
}
// Verify rotate and mask instructions, and further simplified instructions for small types
func bitRotateAndMask(io64 [8]uint64, io32 [4]uint32, io16 [4]uint16, io8 [4]uint8) {
// ppc64x: "RLDICR\t[$]0, R[0-9]*, [$]47, R"
// ppc64x: "RLDICR [$]0, R[0-9]*, [$]47, R"
io64[0] = io64[0] & 0xFFFFFFFFFFFF0000
// ppc64x: "RLDICL\t[$]0, R[0-9]*, [$]16, R"
// ppc64x: "RLDICL [$]0, R[0-9]*, [$]16, R"
io64[1] = io64[1] & 0x0000FFFFFFFFFFFF
// ppc64x: -"SRD", -"AND", "RLDICL\t[$]60, R[0-9]*, [$]16, R"
// ppc64x: -"SRD", -"AND", "RLDICL [$]60, R[0-9]*, [$]16, R"
io64[2] = (io64[2] >> 4) & 0x0000FFFFFFFFFFFF
// ppc64x: -"SRD", -"AND", "RLDICL\t[$]36, R[0-9]*, [$]28, R"
// ppc64x: -"SRD", -"AND", "RLDICL [$]36, R[0-9]*, [$]28, R"
io64[3] = (io64[3] >> 28) & 0x0000FFFFFFFFFFFF
// ppc64x: "MOVWZ", "RLWNM\t[$]1, R[0-9]*, [$]28, [$]3, R"
// ppc64x: "MOVWZ", "RLWNM [$]1, R[0-9]*, [$]28, [$]3, R"
io64[4] = uint64(bits.RotateLeft32(io32[0], 1) & 0xF000000F)
// ppc64x: "RLWNM\t[$]0, R[0-9]*, [$]4, [$]19, R"
// ppc64x: "RLWNM [$]0, R[0-9]*, [$]4, [$]19, R"
io32[0] = io32[0] & 0x0FFFF000
// ppc64x: "RLWNM\t[$]0, R[0-9]*, [$]20, [$]3, R"
// ppc64x: "RLWNM [$]0, R[0-9]*, [$]20, [$]3, R"
io32[1] = io32[1] & 0xF0000FFF
// ppc64x: -"RLWNM", MOVD, AND
io32[2] = io32[2] & 0xFFFF0002
var bigc uint32 = 0x12345678
// ppc64x: "ANDCC\t[$]22136"
// ppc64x: "ANDCC [$]22136"
io16[0] = io16[0] & uint16(bigc)
// ppc64x: "ANDCC\t[$]120"
// ppc64x: "ANDCC [$]120"
io8[0] = io8[0] & uint8(bigc)
}

48
test/codegen/bmi.go
View file

@ -47,41 +47,41 @@ func blsr32(x int32) int32 {
}
func isPowerOfTwo64(x int64) bool {
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
return blsr64(x) == 0
}
func isPowerOfTwo32(x int32) bool {
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
return blsr32(x) == 0
}
func isPowerOfTwoSelect64(x, a, b int64) int64 {
var r int64
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
if isPowerOfTwo64(x) {
r = a
} else {
r = b
}
// amd64/v3:"CMOVQEQ",-"TESTQ",-"CALL"
// amd64/v3:"CMOVQEQ" -"TESTQ" -"CALL"
return r * 2 // force return blocks joining
}
func isPowerOfTwoSelect32(x, a, b int32) int32 {
var r int32
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
if isPowerOfTwo32(x) {
r = a
} else {
r = b
}
// amd64/v3:"CMOVLEQ",-"TESTL",-"CALL"
// amd64/v3:"CMOVLEQ" -"TESTL" -"CALL"
return r * 2 // force return blocks joining
}
func isPowerOfTwoBranch64(x int64, a func(bool), b func(string)) {
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
if isPowerOfTwo64(x) {
a(true)
} else {
@ -90,7 +90,7 @@ func isPowerOfTwoBranch64(x int64, a func(bool), b func(string)) {
}
func isPowerOfTwoBranch32(x int32, a func(bool), b func(string)) {
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
if isPowerOfTwo32(x) {
a(true)
} else {
@ -99,41 +99,41 @@ func isPowerOfTwoBranch32(x int32, a func(bool), b func(string)) {
}
func isNotPowerOfTwo64(x int64) bool {
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
return blsr64(x) != 0
}
func isNotPowerOfTwo32(x int32) bool {
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
return blsr32(x) != 0
}
func isNotPowerOfTwoSelect64(x, a, b int64) int64 {
var r int64
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
if isNotPowerOfTwo64(x) {
r = a
} else {
r = b
}
// amd64/v3:"CMOVQNE",-"TESTQ",-"CALL"
// amd64/v3:"CMOVQNE" -"TESTQ" -"CALL"
return r * 2 // force return blocks joining
}
func isNotPowerOfTwoSelect32(x, a, b int32) int32 {
var r int32
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
if isNotPowerOfTwo32(x) {
r = a
} else {
r = b
}
// amd64/v3:"CMOVLNE",-"TESTL",-"CALL"
// amd64/v3:"CMOVLNE" -"TESTL" -"CALL"
return r * 2 // force return blocks joining
}
func isNotPowerOfTwoBranch64(x int64, a func(bool), b func(string)) {
// amd64/v3:"BLSRQ",-"TESTQ",-"CALL"
// amd64/v3:"BLSRQ" -"TESTQ" -"CALL"
if isNotPowerOfTwo64(x) {
a(true)
} else {
@ -142,7 +142,7 @@ func isNotPowerOfTwoBranch64(x int64, a func(bool), b func(string)) {
}
func isNotPowerOfTwoBranch32(x int32, a func(bool), b func(string)) {
// amd64/v3:"BLSRL",-"TESTL",-"CALL"
// amd64/v3:"BLSRL" -"TESTL" -"CALL"
if isNotPowerOfTwo32(x) {
a(true)
} else {
@ -161,17 +161,17 @@ func sarx32(x, y int32) int32 {
}
func sarx64_load(x []int64, i int) int64 {
// amd64/v3: `SARXQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64/v3: `SARXQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
s := x[i] >> (i & 63)
// amd64/v3: `SARXQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64/v3: `SARXQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
s = x[i+1] >> (s & 63)
return s
}
func sarx32_load(x []int32, i int) int32 {
// amd64/v3: `SARXL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// amd64/v3: `SARXL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
s := x[i] >> (i & 63)
// amd64/v3: `SARXL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// amd64/v3: `SARXL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
s = x[i+1] >> (s & 63)
return s
}
@ -193,17 +193,17 @@ func shlrx32(x, y uint32) uint32 {
}
func shlrx64_load(x []uint64, i int, s uint64) uint64 {
// amd64/v3: `SHRXQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64/v3: `SHRXQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
s = x[i] >> i
// amd64/v3: `SHLXQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64/v3: `SHLXQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
s = x[i+1] << s
return s
}
func shlrx32_load(x []uint32, i int, s uint32) uint32 {
// amd64/v3: `SHRXL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// amd64/v3: `SHRXL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
s = x[i] >> i
// amd64/v3: `SHLXL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// amd64/v3: `SHLXL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
s = x[i+1] << s
return s
}

164
test/codegen/bool.go
View file

@ -13,52 +13,52 @@ import (
// This file contains codegen tests related to boolean simplifications/optimizations.
func convertNeq0B(x uint8, c bool) bool {
// amd64:"ANDL\t[$]1",-"SETNE"
// ppc64x:"RLDICL",-"CMPW",-"ISEL"
// amd64:"ANDL [$]1" -"SETNE"
// ppc64x:"RLDICL" -"CMPW" -"ISEL"
b := x&1 != 0
return c && b
}
func convertNeq0W(x uint16, c bool) bool {
// amd64:"ANDL\t[$]1",-"SETNE"
// ppc64x:"RLDICL",-"CMPW",-"ISEL"
// amd64:"ANDL [$]1" -"SETNE"
// ppc64x:"RLDICL" -"CMPW" -"ISEL"
b := x&1 != 0
return c && b
}
func convertNeq0L(x uint32, c bool) bool {
// amd64:"ANDL\t[$]1",-"SETB"
// ppc64x:"RLDICL",-"CMPW",-"ISEL"
// amd64:"ANDL [$]1" -"SETB"
// ppc64x:"RLDICL" -"CMPW" -"ISEL"
b := x&1 != 0
return c && b
}
func convertNeq0Q(x uint64, c bool) bool {
// amd64:"ANDL\t[$]1",-"SETB"
// ppc64x:"RLDICL",-"CMP",-"ISEL"
// amd64:"ANDL [$]1" -"SETB"
// ppc64x:"RLDICL" -"CMP" -"ISEL"
b := x&1 != 0
return c && b
}
func convertNeqBool32(x uint32) bool {
// ppc64x:"RLDICL",-"CMPW",-"ISEL"
// ppc64x:"RLDICL" -"CMPW" -"ISEL"
return x&1 != 0
}
func convertEqBool32(x uint32) bool {
// ppc64x:"RLDICL",-"CMPW","XOR",-"ISEL"
// amd64:"ANDL","XORL",-"BTL",-"SETCC"
// ppc64x:"RLDICL" -"CMPW" "XOR" -"ISEL"
// amd64:"ANDL" "XORL" -"BTL" -"SETCC"
return x&1 == 0
}
func convertNeqBool64(x uint64) bool {
// ppc64x:"RLDICL",-"CMP",-"ISEL"
// ppc64x:"RLDICL" -"CMP" -"ISEL"
return x&1 != 0
}
func convertEqBool64(x uint64) bool {
// ppc64x:"RLDICL","XOR",-"CMP",-"ISEL"
// amd64:"ANDL","XORL",-"BTL",-"SETCC"
// ppc64x:"RLDICL" "XOR" -"CMP" -"ISEL"
// amd64:"ANDL" "XORL" -"BTL" -"SETCC"
return x&1 == 0
}
@ -87,157 +87,157 @@ func phiOr(a, b bool) bool {
}
func TestSetEq64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBC\tCR0EQ",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0EQ"
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0EQ"
// ppc64x/power10:"SETBC CR0EQ" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0EQ"
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0EQ"
b := x == y
return b
}
func TestSetNeq64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0EQ"
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0EQ"
// ppc64x/power10:"SETBCR CR0EQ" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0EQ"
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0EQ"
b := x != y
return b
}
func TestSetLt64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBC\tCR0GT",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0GT"
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0GT"
// ppc64x/power10:"SETBC CR0GT" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0GT"
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0GT"
b := x < y
return b
}
func TestSetLe64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBCR\tCR0LT",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0LT"
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0LT"
// ppc64x/power10:"SETBCR CR0LT" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0LT"
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0LT"
b := x <= y
return b
}
func TestSetGt64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0LT"
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0LT"
b := x > y
return b
}
func TestSetGe64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBCR\tCR0GT",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0GT"
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0GT"
// ppc64x/power10:"SETBCR CR0GT" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0GT"
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0GT"
b := x >= y
return b
}
func TestSetLtFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT"
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT"
b := x < y
return b
}
func TestSetLeFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBC\tCR0LT","SETBC\tCR0EQ","OR",-"ISEL",-"ISEL"
// ppc64x/power9:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR"
// ppc64x/power8:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR"
// ppc64x/power10:"SETBC CR0LT" "SETBC CR0EQ" "OR" -"ISEL" -"ISEL"
// ppc64x/power9:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR"
// ppc64x/power8:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR"
b := x <= y
return b
}
func TestSetGtFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT"
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT"
b := x > y
return b
}
func TestSetGeFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBC\tCR0LT","SETBC\tCR0EQ","OR",-"ISEL",-"ISEL"
// ppc64x/power9:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR"
// ppc64x/power8:"ISEL","ISEL",-"SETBC\tCR0LT",-"SETBC\tCR0EQ","OR"
// ppc64x/power10:"SETBC CR0LT" "SETBC CR0EQ" "OR" -"ISEL" -"ISEL"
// ppc64x/power9:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR"
// ppc64x/power8:"ISEL" "ISEL" -"SETBC CR0LT" -"SETBC CR0EQ" "OR"
b := x >= y
return b
}
func TestSetInvEq64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0EQ"
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0EQ"
// ppc64x/power10:"SETBCR CR0EQ" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0EQ"
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0EQ"
b := !(x == y)
return b
}
func TestSetInvNeq64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBC\tCR0EQ",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0EQ"
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0EQ"
// ppc64x/power10:"SETBC CR0EQ" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0EQ"
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0EQ"
b := !(x != y)
return b
}
func TestSetInvLt64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBCR\tCR0GT",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0GT"
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0GT"
// ppc64x/power10:"SETBCR CR0GT" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0GT"
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0GT"
b := !(x < y)
return b
}
func TestSetInvLe64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0LT"
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0LT"
b := !(x <= y)
return b
}
func TestSetInvGt64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBCR\tCR0LT",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBCR\tCR0LT"
// ppc64x/power8:"CMP","ISEL",-"SETBCR\tCR0LT"
// ppc64x/power10:"SETBCR CR0LT" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBCR CR0LT"
// ppc64x/power8:"CMP" "ISEL" -"SETBCR CR0LT"
b := !(x > y)
return b
}
func TestSetInvGe64(x uint64, y uint64) bool {
// ppc64x/power10:"SETBC\tCR0GT",-"ISEL"
// ppc64x/power9:"CMP","ISEL",-"SETBC\tCR0GT"
// ppc64x/power8:"CMP","ISEL",-"SETBC\tCR0GT"
// ppc64x/power10:"SETBC CR0GT" -"ISEL"
// ppc64x/power9:"CMP" "ISEL" -"SETBC CR0GT"
// ppc64x/power8:"CMP" "ISEL" -"SETBC CR0GT"
b := !(x >= y)
return b
}
func TestSetInvEqFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBCR\tCR0EQ",-"ISEL"
// ppc64x/power9:"FCMP","ISEL",-"SETBCR\tCR0EQ"
// ppc64x/power8:"FCMP","ISEL",-"SETBCR\tCR0EQ"
// ppc64x/power10:"SETBCR CR0EQ" -"ISEL"
// ppc64x/power9:"FCMP" "ISEL" -"SETBCR CR0EQ"
// ppc64x/power8:"FCMP" "ISEL" -"SETBCR CR0EQ"
b := !(x == y)
return b
}
func TestSetInvNeqFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBC\tCR0EQ",-"ISEL"
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0EQ"
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0EQ"
// ppc64x/power10:"SETBC CR0EQ" -"ISEL"
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0EQ"
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0EQ"
b := !(x != y)
return b
}
func TestSetInvLtFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBCR\tCR0LT",-"ISEL"
// ppc64x/power9:"FCMP","ISEL",-"SETBCR\tCR0LT"
// ppc64x/power8:"FCMP","ISEL",-"SETBCR\tCR0LT"
// ppc64x/power10:"SETBCR CR0LT" -"ISEL"
// ppc64x/power9:"FCMP" "ISEL" -"SETBCR CR0LT"
// ppc64x/power8:"FCMP" "ISEL" -"SETBCR CR0LT"
b := !(x < y)
return b
}
func TestSetInvLeFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT"
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT"
b := !(x <= y)
return b
}
func TestSetInvGtFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBCR\tCR0LT",-"ISEL"
// ppc64x/power9:"FCMP","ISEL",-"SETBCR\tCR0LT"
// ppc64x/power8:"FCMP","ISEL",-"SETBCR\tCR0LT"
// ppc64x/power10:"SETBCR CR0LT" -"ISEL"
// ppc64x/power9:"FCMP" "ISEL" -"SETBCR CR0LT"
// ppc64x/power8:"FCMP" "ISEL" -"SETBCR CR0LT"
b := !(x > y)
return b
}
func TestSetInvGeFp64(x float64, y float64) bool {
// ppc64x/power10:"SETBC\tCR0LT",-"ISEL"
// ppc64x/power9:"FCMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power8:"FCMP","ISEL",-"SETBC\tCR0LT"
// ppc64x/power10:"SETBC CR0LT" -"ISEL"
// ppc64x/power9:"FCMP" "ISEL" -"SETBC CR0LT"
// ppc64x/power8:"FCMP" "ISEL" -"SETBC CR0LT"
b := !(x >= y)
return b
}
@ -293,7 +293,7 @@ func TestLogicalCompareZero(x *[64]uint64) {
x[12] = b
}
// ppc64x:"ADDCCC\t[$]4,"
// ppc64x:"ADDCCC [$]4,"
c := int64(x[12]) + 4
if c <= 0 {
x[12] = uint64(c)
@ -309,7 +309,7 @@ func TestLogicalCompareZero(x *[64]uint64) {
func constantWrite(b bool, p *bool) {
if b {
// amd64:`MOVB\t[$]1, \(`
// amd64:`MOVB [$]1, \(`
*p = b
}
}

12
test/codegen/clobberdead.go
View file

@ -15,16 +15,16 @@ var p1, p2, p3 T
func F() {
// 3735936685 is 0xdeaddead. On ARM64 R27 is REGTMP.
// clobber x, y at entry. not clobber z (stack object).
// amd64:`MOVL\t\$3735936685, command-line-arguments\.x`, `MOVL\t\$3735936685, command-line-arguments\.y`, -`MOVL\t\$3735936685, command-line-arguments\.z`
// arm64:`MOVW\tR27, command-line-arguments\.x`, `MOVW\tR27, command-line-arguments\.y`, -`MOVW\tR27, command-line-arguments\.z`
// amd64:`MOVL \$3735936685, command-line-arguments\.x`, `MOVL \$3735936685, command-line-arguments\.y`, -`MOVL \$3735936685, command-line-arguments\.z`
// arm64:`MOVW R27, command-line-arguments\.x`, `MOVW R27, command-line-arguments\.y`, -`MOVW R27, command-line-arguments\.z`
x, y, z := p1, p2, p3
addrTaken(&z)
// x is dead at the call (the value of x is loaded before the CALL), y is not
// amd64:`MOVL\t\$3735936685, command-line-arguments\.x`, -`MOVL\t\$3735936685, command-line-arguments\.y`
// arm64:`MOVW\tR27, command-line-arguments\.x`, -`MOVW\tR27, command-line-arguments\.y`
// amd64:`MOVL \$3735936685, command-line-arguments\.x`, -`MOVL \$3735936685, command-line-arguments\.y`
// arm64:`MOVW R27, command-line-arguments\.x`, -`MOVW R27, command-line-arguments\.y`
use(x)
// amd64:`MOVL\t\$3735936685, command-line-arguments\.x`, `MOVL\t\$3735936685, command-line-arguments\.y`
// arm64:`MOVW\tR27, command-line-arguments\.x`, `MOVW\tR27, command-line-arguments\.y`
// amd64:`MOVL \$3735936685, command-line-arguments\.x`, `MOVL \$3735936685, command-line-arguments\.y`
// arm64:`MOVW R27, command-line-arguments\.x`, `MOVW R27, command-line-arguments\.y`
use(y)
}

14
test/codegen/clobberdeadreg.go
View file

@ -14,14 +14,14 @@ type S struct {
func F(a, b, c int, d S) {
// -2401018187971961171 is 0xdeaddeaddeaddead
// amd64:`MOVQ\t\$-2401018187971961171, AX`, `MOVQ\t\$-2401018187971961171, BX`, `MOVQ\t\$-2401018187971961171, CX`
// amd64:`MOVQ\t\$-2401018187971961171, DX`, `MOVQ\t\$-2401018187971961171, SI`, `MOVQ\t\$-2401018187971961171, DI`
// amd64:`MOVQ\t\$-2401018187971961171, R8`, `MOVQ\t\$-2401018187971961171, R9`, `MOVQ\t\$-2401018187971961171, R10`
// amd64:`MOVQ\t\$-2401018187971961171, R11`, `MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`
// amd64:-`MOVQ\t\$-2401018187971961171, BP` // frame pointer is not clobbered
// amd64:`MOVQ \$-2401018187971961171, AX`, `MOVQ \$-2401018187971961171, BX`, `MOVQ \$-2401018187971961171, CX`
// amd64:`MOVQ \$-2401018187971961171, DX`, `MOVQ \$-2401018187971961171, SI`, `MOVQ \$-2401018187971961171, DI`
// amd64:`MOVQ \$-2401018187971961171, R8`, `MOVQ \$-2401018187971961171, R9`, `MOVQ \$-2401018187971961171, R10`
// amd64:`MOVQ \$-2401018187971961171, R11`, `MOVQ \$-2401018187971961171, R12`, `MOVQ \$-2401018187971961171, R13`
// amd64:-`MOVQ \$-2401018187971961171, BP` // frame pointer is not clobbered
StackArgsCall([10]int{a, b, c})
// amd64:`MOVQ\t\$-2401018187971961171, R12`, `MOVQ\t\$-2401018187971961171, R13`, `MOVQ\t\$-2401018187971961171, DX`
// amd64:-`MOVQ\t\$-2401018187971961171, AX`, -`MOVQ\t\$-2401018187971961171, R11` // register args are not clobbered
// amd64:`MOVQ \$-2401018187971961171, R12`, `MOVQ \$-2401018187971961171, R13`, `MOVQ \$-2401018187971961171, DX`
// amd64:-`MOVQ \$-2401018187971961171, AX`, -`MOVQ \$-2401018187971961171, R11` // register args are not clobbered
RegArgsCall(a, b, c, d)
}

64
test/codegen/compare_and_branch.go
View file

@ -11,12 +11,12 @@ func dummy() {}
// Signed 64-bit compare-and-branch.
func si64(x, y chan int64) {
// s390x:"CGRJ\t[$](2|4), R[0-9]+, R[0-9]+, "
// s390x:"CGRJ [$](2|4), R[0-9]+, R[0-9]+, "
for <-x < <-y {
dummy()
}
// s390x:"CL?GRJ\t[$]8, R[0-9]+, R[0-9]+, "
// s390x:"CL?GRJ [$]8, R[0-9]+, R[0-9]+, "
for <-x == <-y {
dummy()
}
@ -25,22 +25,22 @@ func si64(x, y chan int64) {
// Signed 64-bit compare-and-branch with 8-bit immediate.
func si64x8(doNotOptimize int64) {
// take in doNotOptimize as an argument to avoid the loops being rewritten to count down
// s390x:"CGIJ\t[$]12, R[0-9]+, [$]127, "
// s390x:"CGIJ [$]12, R[0-9]+, [$]127, "
for i := doNotOptimize; i < 128; i++ {
dummy()
}
// s390x:"CGIJ\t[$]10, R[0-9]+, [$]-128, "
// s390x:"CGIJ [$]10, R[0-9]+, [$]-128, "
for i := doNotOptimize; i > -129; i-- {
dummy()
}
// s390x:"CGIJ\t[$]2, R[0-9]+, [$]127, "
// s390x:"CGIJ [$]2, R[0-9]+, [$]127, "
for i := doNotOptimize; i >= 128; i++ {
dummy()
}
// s390x:"CGIJ\t[$]4, R[0-9]+, [$]-128, "
// s390x:"CGIJ [$]4, R[0-9]+, [$]-128, "
for i := doNotOptimize; i <= -129; i-- {
dummy()
}
@ -48,12 +48,12 @@ func si64x8(doNotOptimize int64) {
// Unsigned 64-bit compare-and-branch.
func ui64(x, y chan uint64) {
// s390x:"CLGRJ\t[$](2|4), R[0-9]+, R[0-9]+, "
// s390x:"CLGRJ [$](2|4), R[0-9]+, R[0-9]+, "
for <-x > <-y {
dummy()
}
// s390x:"CL?GRJ\t[$]6, R[0-9]+, R[0-9]+, "
// s390x:"CL?GRJ [$]6, R[0-9]+, R[0-9]+, "
for <-x != <-y {
dummy()
}
@ -61,22 +61,22 @@ func ui64(x, y chan uint64) {
// Unsigned 64-bit comparison with 8-bit immediate.
func ui64x8() {
// s390x:"CLGIJ\t[$]4, R[0-9]+, [$]128, "
// s390x:"CLGIJ [$]4, R[0-9]+, [$]128, "
for i := uint64(0); i < 128; i++ {
dummy()
}
// s390x:"CLGIJ\t[$]12, R[0-9]+, [$]255, "
// s390x:"CLGIJ [$]12, R[0-9]+, [$]255, "
for i := uint64(0); i < 256; i++ {
dummy()
}
// s390x:"CLGIJ\t[$]2, R[0-9]+, [$]255, "
// s390x:"CLGIJ [$]2, R[0-9]+, [$]255, "
for i := uint64(257); i >= 256; i-- {
dummy()
}
// s390x:"CLGIJ\t[$]2, R[0-9]+, [$]0, "
// s390x:"CLGIJ [$]2, R[0-9]+, [$]0, "
for i := uint64(1024); i > 0; i-- {
dummy()
}
@ -84,12 +84,12 @@ func ui64x8() {
// Signed 32-bit compare-and-branch.
func si32(x, y chan int32) {
// s390x:"CRJ\t[$](2|4), R[0-9]+, R[0-9]+, "
// s390x:"CRJ [$](2|4), R[0-9]+, R[0-9]+, "
for <-x < <-y {
dummy()
}
// s390x:"CL?RJ\t[$]8, R[0-9]+, R[0-9]+, "
// s390x:"CL?RJ [$]8, R[0-9]+, R[0-9]+, "
for <-x == <-y {
dummy()
}
@ -98,22 +98,22 @@ func si32(x, y chan int32) {
// Signed 32-bit compare-and-branch with 8-bit immediate.
func si32x8(doNotOptimize int32) {
// take in doNotOptimize as an argument to avoid the loops being rewritten to count down
// s390x:"CIJ\t[$]12, R[0-9]+, [$]127, "
// s390x:"CIJ [$]12, R[0-9]+, [$]127, "
for i := doNotOptimize; i < 128; i++ {
dummy()
}
// s390x:"CIJ\t[$]10, R[0-9]+, [$]-128, "
// s390x:"CIJ [$]10, R[0-9]+, [$]-128, "
for i := doNotOptimize; i > -129; i-- {
dummy()
}
// s390x:"CIJ\t[$]2, R[0-9]+, [$]127, "
// s390x:"CIJ [$]2, R[0-9]+, [$]127, "
for i := doNotOptimize; i >= 128; i++ {
dummy()
}
// s390x:"CIJ\t[$]4, R[0-9]+, [$]-128, "
// s390x:"CIJ [$]4, R[0-9]+, [$]-128, "
for i := doNotOptimize; i <= -129; i-- {
dummy()
}
@ -121,12 +121,12 @@ func si32x8(doNotOptimize int32) {
// Unsigned 32-bit compare-and-branch.
func ui32(x, y chan uint32) {
// s390x:"CLRJ\t[$](2|4), R[0-9]+, R[0-9]+, "
// s390x:"CLRJ [$](2|4), R[0-9]+, R[0-9]+, "
for <-x > <-y {
dummy()
}
// s390x:"CL?RJ\t[$]6, R[0-9]+, R[0-9]+, "
// s390x:"CL?RJ [$]6, R[0-9]+, R[0-9]+, "
for <-x != <-y {
dummy()
}
@ -134,22 +134,22 @@ func ui32(x, y chan uint32) {
// Unsigned 32-bit comparison with 8-bit immediate.
func ui32x8() {
// s390x:"CLIJ\t[$]4, R[0-9]+, [$]128, "
// s390x:"CLIJ [$]4, R[0-9]+, [$]128, "
for i := uint32(0); i < 128; i++ {
dummy()
}
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255, "
// s390x:"CLIJ [$]12, R[0-9]+, [$]255, "
for i := uint32(0); i < 256; i++ {
dummy()
}
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]255, "
// s390x:"CLIJ [$]2, R[0-9]+, [$]255, "
for i := uint32(257); i >= 256; i-- {
dummy()
}
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]0, "
// s390x:"CLIJ [$]2, R[0-9]+, [$]0, "
for i := uint32(1024); i > 0; i-- {
dummy()
}
@ -157,12 +157,12 @@ func ui32x8() {
// Signed 64-bit comparison with unsigned 8-bit immediate.
func si64xu8(x chan int64) {
// s390x:"CLGIJ\t[$]8, R[0-9]+, [$]128, "
// s390x:"CLGIJ [$]8, R[0-9]+, [$]128, "
for <-x == 128 {
dummy()
}
// s390x:"CLGIJ\t[$]6, R[0-9]+, [$]255, "
// s390x:"CLGIJ [$]6, R[0-9]+, [$]255, "
for <-x != 255 {
dummy()
}
@ -170,12 +170,12 @@ func si64xu8(x chan int64) {
// Signed 32-bit comparison with unsigned 8-bit immediate.
func si32xu8(x chan int32) {
// s390x:"CLIJ\t[$]8, R[0-9]+, [$]255, "
// s390x:"CLIJ [$]8, R[0-9]+, [$]255, "
for <-x == 255 {
dummy()
}
// s390x:"CLIJ\t[$]6, R[0-9]+, [$]128, "
// s390x:"CLIJ [$]6, R[0-9]+, [$]128, "
for <-x != 128 {
dummy()
}
@ -183,12 +183,12 @@ func si32xu8(x chan int32) {
// Unsigned 64-bit comparison with signed 8-bit immediate.
func ui64xu8(x chan uint64) {
// s390x:"CGIJ\t[$]8, R[0-9]+, [$]-1, "
// s390x:"CGIJ [$]8, R[0-9]+, [$]-1, "
for <-x == ^uint64(0) {
dummy()
}
// s390x:"CGIJ\t[$]6, R[0-9]+, [$]-128, "
// s390x:"CGIJ [$]6, R[0-9]+, [$]-128, "
for <-x != ^uint64(127) {
dummy()
}
@ -196,12 +196,12 @@ func ui64xu8(x chan uint64) {
// Unsigned 32-bit comparison with signed 8-bit immediate.
func ui32xu8(x chan uint32) {
// s390x:"CIJ\t[$]8, R[0-9]+, [$]-128, "
// s390x:"CIJ [$]8, R[0-9]+, [$]-128, "
for <-x == ^uint32(127) {
dummy()
}
// s390x:"CIJ\t[$]6, R[0-9]+, [$]-1, "
// s390x:"CIJ [$]6, R[0-9]+, [$]-1, "
for <-x != ^uint32(0) {
dummy()
}

112
test/codegen/comparisons.go
View file

@ -21,68 +21,68 @@ import (
// Check that compare to constant string use 2/4/8 byte compares
func CompareString1(s string) bool {
// amd64:`CMPW\t\(.*\), [$]`
// arm64:`MOVHU\t\(.*\), [R]`,`MOVD\t[$]`,`CMPW\tR`
// ppc64le:`MOVHZ\t\(.*\), [R]`,`CMPW\t.*, [$]`
// s390x:`MOVHBR\t\(.*\), [R]`,`CMPW\t.*, [$]`
// amd64:`CMPW \(.*\), [$]`
// arm64:`MOVHU \(.*\), [R]`,`MOVD [$]`,`CMPW R`
// ppc64le:`MOVHZ \(.*\), [R]`,`CMPW .*, [$]`
// s390x:`MOVHBR \(.*\), [R]`,`CMPW .*, [$]`
return s == "xx"
}
func CompareString2(s string) bool {
// amd64:`CMPL\t\(.*\), [$]`
// arm64:`MOVWU\t\(.*\), [R]`,`CMPW\t.*, [R]`
// ppc64le:`MOVWZ\t\(.*\), [R]`,`CMPW\t.*, [R]`
// s390x:`MOVWBR\t\(.*\), [R]`,`CMPW\t.*, [$]`
// amd64:`CMPL \(.*\), [$]`
// arm64:`MOVWU \(.*\), [R]`,`CMPW .*, [R]`
// ppc64le:`MOVWZ \(.*\), [R]`,`CMPW .*, [R]`
// s390x:`MOVWBR \(.*\), [R]`,`CMPW .*, [$]`
return s == "xxxx"
}
func CompareString3(s string) bool {
// amd64:`CMPQ\t\(.*\), [A-Z]`
// arm64:-`CMPW\t`
// ppc64x:-`CMPW\t`
// s390x:-`CMPW\t`
// amd64:`CMPQ \(.*\), [A-Z]`
// arm64:-`CMPW `
// ppc64x:-`CMPW `
// s390x:-`CMPW `
return s == "xxxxxxxx"
}
// Check that arrays compare use 2/4/8 byte compares
func CompareArray1(a, b [2]byte) bool {
// amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// arm64:-`MOVBU\t`
// ppc64le:-`MOVBZ\t`
// s390x:-`MOVBZ\t`
// amd64:`CMPW command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// arm64:-`MOVBU `
// ppc64le:-`MOVBZ `
// s390x:-`MOVBZ `
return a == b
}
func CompareArray2(a, b [3]uint16) bool {
// amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPL command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPW command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
return a == b
}
func CompareArray3(a, b [3]int16) bool {
// amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPW\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPL command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPW command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
return a == b
}
func CompareArray4(a, b [12]int8) bool {
// amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPL\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPL command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
return a == b
}
func CompareArray5(a, b [15]byte) bool {
// amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
return a == b
}
// This was a TODO in mapaccess1_faststr
func CompareArray6(a, b unsafe.Pointer) bool {
// amd64:`CMPL\t\(.*\), [A-Z]`
// arm64:`MOVWU\t\(.*\), [R]`,`CMPW\t.*, [R]`
// ppc64le:`MOVWZ\t\(.*\), [R]`,`CMPW\t.*, [R]`
// s390x:`MOVWBR\t\(.*\), [R]`,`CMPW\t.*, [R]`
// amd64:`CMPL \(.*\), [A-Z]`
// arm64:`MOVWU \(.*\), [R]`,`CMPW .*, [R]`
// ppc64le:`MOVWZ \(.*\), [R]`,`CMPW .*, [R]`
// s390x:`MOVWBR \(.*\), [R]`,`CMPW .*, [R]`
return *((*[4]byte)(a)) != *((*[4]byte)(b))
}
@ -93,7 +93,7 @@ type T1 struct {
}
func CompareStruct1(s1, s2 T1) bool {
// amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:-`CALL`
return s1 == s2
}
@ -103,7 +103,7 @@ type T2 struct {
}
func CompareStruct2(s1, s2 T2) bool {
// amd64:`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:-`CALL`
return s1 == s2
}
@ -116,7 +116,7 @@ type T3 struct {
}
func CompareStruct3(s1, s2 T3) bool {
// amd64:-`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:-`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CALL`
return s1 == s2
}
@ -126,7 +126,7 @@ type T4 struct {
}
func CompareStruct4(s1, s2 T4) bool {
// amd64:-`CMPQ\tcommand-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:-`CMPQ command-line-arguments[.+_a-z0-9]+\(SP\), [A-Z]`
// amd64:`CALL`
return s1 == s2
}
@ -140,7 +140,7 @@ func CompareStruct4(s1, s2 T4) bool {
var r bool
func CmpFold(x uint32) {
// amd64:`SETHI\t.*\(SB\)`
// amd64:`SETHI .*\(SB\)`
r = x > 4
}
@ -148,27 +148,27 @@ func CmpFold(x uint32) {
// possible
func CmpMem1(p int, q *int) bool {
// amd64:`CMPQ\t\(.*\), [A-Z]`
// amd64:`CMPQ \(.*\), [A-Z]`
return p < *q
}
func CmpMem2(p *int, q int) bool {
// amd64:`CMPQ\t\(.*\), [A-Z]`
// amd64:`CMPQ \(.*\), [A-Z]`
return *p < q
}
func CmpMem3(p *int) bool {
// amd64:`CMPQ\t\(.*\), [$]7`
// amd64:`CMPQ \(.*\), [$]7`
return *p < 7
}
func CmpMem4(p *int) bool {
// amd64:`CMPQ\t\(.*\), [$]7`
// amd64:`CMPQ \(.*\), [$]7`
return 7 < *p
}
func CmpMem5(p **int) {
// amd64:`CMPL\truntime.writeBarrier\(SB\), [$]0`
// amd64:`CMPL runtime.writeBarrier\(SB\), [$]0`
*p = nil
}
@ -270,31 +270,31 @@ func CmpToZero(a, b, d int32, e, f int64, deOptC0, deOptC1 bool) int32 {
func CmpLogicalToZero(a, b, c uint32, d, e, f, g uint64) uint64 {
// ppc64x:"ANDCC",-"CMPW"
// wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
// ppc64x:"ANDCC" -"CMPW"
// wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
if a&63 == 0 {
return 1
}
// ppc64x:"ANDCC",-"CMP"
// wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
// ppc64x:"ANDCC" -"CMP"
// wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
if d&255 == 0 {
return 1
}
// ppc64x:"ANDCC",-"CMP"
// wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
// ppc64x:"ANDCC" -"CMP"
// wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
if d&e == 0 {
return 1
}
// ppc64x:"ORCC",-"CMP"
// wasm:"I64Eqz",-"I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
// ppc64x:"ORCC" -"CMP"
// wasm:"I64Eqz" -"I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
if f|g == 0 {
return 1
}
// ppc64x:"XORCC",-"CMP"
// wasm:"I64Eqz","I32Eqz",-"I64ExtendI32U",-"I32WrapI64"
// ppc64x:"XORCC" -"CMP"
// wasm:"I64Eqz" "I32Eqz" -"I64ExtendI32U" -"I32WrapI64"
if e^d == 0 {
return 1
}
@ -711,19 +711,19 @@ func cmpToCmn(a, b, c, d int) int {
func cmpToCmnLessThan(a, b, c, d int) int {
var c1, c2, c3, c4 int
// arm64:`CMN`,`CSET\tMI`,-`CMP`
// arm64:`CMN`,`CSET MI`,-`CMP`
if a+1 < 0 {
c1 = 1
}
// arm64:`CMN`,`CSET\tMI`,-`CMP`
// arm64:`CMN`,`CSET MI`,-`CMP`
if a+b < 0 {
c2 = 1
}
// arm64:`CMN`,`CSET\tMI`,-`CMP`
// arm64:`CMN`,`CSET MI`,-`CMP`
if a*b+c < 0 {
c3 = 1
}
// arm64:`CMP`,`CSET\tMI`,-`CMN`
// arm64:`CMP`,`CSET MI`,-`CMN`
if a-b*c < 0 {
c4 = 1
}
@ -780,19 +780,19 @@ func ge128Signed64(x int64) bool {
func cmpToCmnGreaterThanEqual(a, b, c, d int) int {
var c1, c2, c3, c4 int
// arm64:`CMN`,`CSET\tPL`,-`CMP`
// arm64:`CMN`,`CSET PL`,-`CMP`
if a+1 >= 0 {
c1 = 1
}
// arm64:`CMN`,`CSET\tPL`,-`CMP`
// arm64:`CMN`,`CSET PL`,-`CMP`
if a+b >= 0 {
c2 = 1
}
// arm64:`CMN`,`CSET\tPL`,-`CMP`
// arm64:`CMN`,`CSET PL`,-`CMP`
if a*b+c >= 0 {
c3 = 1
}
// arm64:`CMP`,`CSET\tPL`,-`CMN`
// arm64:`CMP`,`CSET PL`,-`CMN`
if a-b*c >= 0 {
c4 = 1
}
@ -870,6 +870,6 @@ func cmpstring2(x, y string) int {
// like in cmpstring1 will not work. Instead, we
// look for spill/restore instructions, which only
// need to exist if there are 2 calls.
//amd64:-`MOVQ\t.*\(SP\)`
//amd64:-`MOVQ .*\(SP\)`
return cmp.Compare(x, y)
}

110
test/codegen/condmove.go
View file

@ -12,8 +12,8 @@ func cmovint(c int) int {
x = 182
}
// amd64:"CMOVQLT"
// arm64:"CSEL\tLT"
// ppc64x:"ISEL\t[$]0"
// arm64:"CSEL LT"
// ppc64x:"ISEL [$]0"
// wasm:"Select"
return x
}
@ -23,8 +23,8 @@ func cmovchan(x, y chan int) chan int {
x = y
}
// amd64:"CMOVQNE"
// arm64:"CSEL\tNE"
// ppc64x:"ISEL\t[$]2"
// arm64:"CSEL NE"
// ppc64x:"ISEL [$]2"
// wasm:"Select"
return x
}
@ -34,8 +34,8 @@ func cmovuintptr(x, y uintptr) uintptr {
x = -y
}
// amd64:"CMOVQ(HI|CS)"
// arm64:"CSNEG\tLS"
// ppc64x:"ISEL\t[$]1"
// arm64:"CSNEG LS"
// ppc64x:"ISEL [$]1"
// wasm:"Select"
return x
}
@ -45,8 +45,8 @@ func cmov32bit(x, y uint32) uint32 {
x = -y
}
// amd64:"CMOVL(HI|CS)"
// arm64:"CSNEG\t(LS|HS)"
// ppc64x:"ISEL\t[$]1"
// arm64:"CSNEG (LS|HS)"
// ppc64x:"ISEL [$]1"
// wasm:"Select"
return x
}
@ -56,8 +56,8 @@ func cmov16bit(x, y uint16) uint16 {
x = -y
}
// amd64:"CMOVW(HI|CS)"
// arm64:"CSNEG\t(LS|HS)"
// ppc64x:"ISEL\t[$][01]"
// arm64:"CSNEG (LS|HS)"
// ppc64x:"ISEL [$][01]"
// wasm:"Select"
return x
}
@ -69,9 +69,9 @@ func cmovfloateq(x, y float64) int {
if x == y {
a = 256
}
// amd64:"CMOVQNE","CMOVQPC"
// arm64:"CSEL\tEQ"
// ppc64x:"ISEL\t[$]2"
// amd64:"CMOVQNE" "CMOVQPC"
// arm64:"CSEL EQ"
// ppc64x:"ISEL [$]2"
// wasm:"Select"
return a
}
@ -81,9 +81,9 @@ func cmovfloatne(x, y float64) int {
if x != y {
a = 256
}
// amd64:"CMOVQNE","CMOVQPS"
// arm64:"CSEL\tNE"
// ppc64x:"ISEL\t[$]2"
// amd64:"CMOVQNE" "CMOVQPS"
// arm64:"CSEL NE"
// ppc64x:"ISEL [$]2"
// wasm:"Select"
return a
}
@ -109,8 +109,8 @@ func cmovfloatint2(x, y float64) float64 {
rexp = rexp - 42
}
// amd64:"CMOVQHI"
// arm64:"CSEL\tMI"
// ppc64x:"ISEL\t[$]0"
// arm64:"CSEL MI"
// ppc64x:"ISEL [$]0"
// wasm:"Select"
r = r - ldexp(y, rexp-yexp)
}
@ -124,8 +124,8 @@ func cmovloaded(x [4]int, y int) int {
y = y >> 2
}
// amd64:"CMOVQNE"
// arm64:"CSEL\tNE"
// ppc64x:"ISEL\t[$]2"
// arm64:"CSEL NE"
// ppc64x:"ISEL [$]2"
// wasm:"Select"
return y
}
@ -136,8 +136,8 @@ func cmovuintptr2(x, y uintptr) uintptr {
a = 256
}
// amd64:"CMOVQEQ"
// arm64:"CSEL\tEQ"
// ppc64x:"ISEL\t[$]2"
// arm64:"CSEL EQ"
// ppc64x:"ISEL [$]2"
// wasm:"Select"
return a
}
@ -230,7 +230,7 @@ func cmovinc(cond bool, a, b, c int) {
} else {
x0 = b + 1
}
// arm64:"CSINC\tNE", -"CSEL"
// arm64:"CSINC NE", -"CSEL"
r0 = x0
if cond {
@ -238,13 +238,13 @@ func cmovinc(cond bool, a, b, c int) {
} else {
x1 = a
}
// arm64:"CSINC\tEQ", -"CSEL"
// arm64:"CSINC EQ", -"CSEL"
r1 = x1
if cond {
c++
}
// arm64:"CSINC\tEQ", -"CSEL"
// arm64:"CSINC EQ", -"CSEL"
r2 = c
}
@ -256,7 +256,7 @@ func cmovinv(cond bool, a, b int) {
} else {
x0 = ^b
}
// arm64:"CSINV\tNE", -"CSEL"
// arm64:"CSINV NE", -"CSEL"
r0 = x0
if cond {
@ -264,7 +264,7 @@ func cmovinv(cond bool, a, b int) {
} else {
x1 = a
}
// arm64:"CSINV\tEQ", -"CSEL"
// arm64:"CSINV EQ", -"CSEL"
r1 = x1
}
@ -276,7 +276,7 @@ func cmovneg(cond bool, a, b, c int) {
} else {
x0 = -b
}
// arm64:"CSNEG\tNE", -"CSEL"
// arm64:"CSNEG NE", -"CSEL"
r0 = x0
if cond {
@ -284,7 +284,7 @@ func cmovneg(cond bool, a, b, c int) {
} else {
x1 = a
}
// arm64:"CSNEG\tEQ", -"CSEL"
// arm64:"CSNEG EQ", -"CSEL"
r1 = x1
}
@ -296,7 +296,7 @@ func cmovsetm(cond bool, x int) {
} else {
x0 = 0
}
// arm64:"CSETM\tNE", -"CSEL"
// arm64:"CSETM NE", -"CSEL"
r0 = x0
if cond {
@ -304,7 +304,7 @@ func cmovsetm(cond bool, x int) {
} else {
x1 = -1
}
// arm64:"CSETM\tEQ", -"CSEL"
// arm64:"CSETM EQ", -"CSEL"
r1 = x1
}
@ -316,7 +316,7 @@ func cmovFcmp0(s, t float64, a, b int) {
} else {
x0 = b + 1
}
// arm64:"CSINC\tMI", -"CSEL"
// arm64:"CSINC MI", -"CSEL"
r0 = x0
if s <= t {
@ -324,7 +324,7 @@ func cmovFcmp0(s, t float64, a, b int) {
} else {
x1 = ^b
}
// arm64:"CSINV\tLS", -"CSEL"
// arm64:"CSINV LS", -"CSEL"
r1 = x1
if s > t {
@ -332,7 +332,7 @@ func cmovFcmp0(s, t float64, a, b int) {
} else {
x2 = -b
}
// arm64:"CSNEG\tMI", -"CSEL"
// arm64:"CSNEG MI", -"CSEL"
r2 = x2
if s >= t {
@ -340,7 +340,7 @@ func cmovFcmp0(s, t float64, a, b int) {
} else {
x3 = 0
}
// arm64:"CSETM\tLS", -"CSEL"
// arm64:"CSETM LS", -"CSEL"
r3 = x3
if s == t {
@ -348,7 +348,7 @@ func cmovFcmp0(s, t float64, a, b int) {
} else {
x4 = b + 1
}
// arm64:"CSINC\tEQ", -"CSEL"
// arm64:"CSINC EQ", -"CSEL"
r4 = x4
if s != t {
@ -356,7 +356,7 @@ func cmovFcmp0(s, t float64, a, b int) {
} else {
x5 = b + 1
}
// arm64:"CSINC\tNE", -"CSEL"
// arm64:"CSINC NE", -"CSEL"
r5 = x5
}
@ -368,7 +368,7 @@ func cmovFcmp1(s, t float64, a, b int) {
} else {
x0 = a
}
// arm64:"CSINC\tPL", -"CSEL"
// arm64:"CSINC PL", -"CSEL"
r0 = x0
if s <= t {
@ -376,7 +376,7 @@ func cmovFcmp1(s, t float64, a, b int) {
} else {
x1 = a
}
// arm64:"CSINV\tHI", -"CSEL"
// arm64:"CSINV HI", -"CSEL"
r1 = x1
if s > t {
@ -384,7 +384,7 @@ func cmovFcmp1(s, t float64, a, b int) {
} else {
x2 = a
}
// arm64:"CSNEG\tPL", -"CSEL"
// arm64:"CSNEG PL", -"CSEL"
r2 = x2
if s >= t {
@ -392,7 +392,7 @@ func cmovFcmp1(s, t float64, a, b int) {
} else {
x3 = -1
}
// arm64:"CSETM\tHI", -"CSEL"
// arm64:"CSETM HI", -"CSEL"
r3 = x3
if s == t {
@ -400,7 +400,7 @@ func cmovFcmp1(s, t float64, a, b int) {
} else {
x4 = a
}
// arm64:"CSINC\tNE", -"CSEL"
// arm64:"CSINC NE", -"CSEL"
r4 = x4
if s != t {
@ -408,7 +408,7 @@ func cmovFcmp1(s, t float64, a, b int) {
} else {
x5 = a
}
// arm64:"CSINC\tEQ", -"CSEL"
// arm64:"CSINC EQ", -"CSEL"
r5 = x5
}
@ -439,7 +439,7 @@ func cmovzeroreg0(a, b int) int {
if a == b {
x = a
}
// ppc64x:"ISEL\t[$]2, R[0-9]+, R0, R[0-9]+"
// ppc64x:"ISEL [$]2, R[0-9]+, R0, R[0-9]+"
return x
}
@ -448,7 +448,7 @@ func cmovzeroreg1(a, b int) int {
if a == b {
x = 0
}
// ppc64x:"ISEL\t[$]2, R0, R[0-9]+, R[0-9]+"
// ppc64x:"ISEL [$]2, R0, R[0-9]+, R[0-9]+"
return x
}
@ -507,3 +507,23 @@ func cmovmathhalveu(a uint, b bool) uint {
// wasm:"I64ShrU", -"Select"
return a
}
func branchlessBoolToUint8(b bool) (r uint8) {
if b {
r = 1
}
return
}
func cmovFromMulFromFlags64(x uint64, b bool) uint64 {
// amd64:-"MOVB.ZX"
r := uint64(branchlessBoolToUint8(b))
// amd64:"CMOV",-"MOVB.ZX",-"MUL"
return x * r
}
func cmovFromMulFromFlags64sext(x int64, b bool) int64 {
// amd64:-"MOVB.ZX"
r := int64(int8(branchlessBoolToUint8(b)))
// amd64:"CMOV",-"MOVB.ZX",-"MUL"
return x * r
}

26
test/codegen/constants.go
View file

@ -7,27 +7,29 @@
package codegen
// A uint16 or sint16 constant shifted left.
func shifted16BitConstants(out [64]uint64) {
// ppc64x: "MOVD\t[$]8193,", "SLD\t[$]27,"
func shifted16BitConstants() (out [64]uint64) {
// ppc64x: "MOVD [$]8193,", "SLD [$]27,"
out[0] = 0x0000010008000000
// ppc64x: "MOVD\t[$]-32767", "SLD\t[$]26,"
// ppc64x: "MOVD [$]-32767", "SLD [$]26,"
out[1] = 0xFFFFFE0004000000
// ppc64x: "MOVD\t[$]-1", "SLD\t[$]48,"
// ppc64x: "MOVD [$]-1", "SLD [$]48,"
out[2] = 0xFFFF000000000000
// ppc64x: "MOVD\t[$]65535", "SLD\t[$]44,"
// ppc64x: "MOVD [$]65535", "SLD [$]44,"
out[3] = 0x0FFFF00000000000
return
}
// A contiguous set of 1 bits, potentially wrapping.
func contiguousMaskConstants(out [64]uint64) {
// ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]44, [$]63,"
func contiguousMaskConstants() (out [64]uint64) {
// ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]44, [$]63,"
out[0] = 0xFFFFF00000000001
// ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]43, [$]63,"
// ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]43, [$]63,"
out[1] = 0xFFFFF80000000001
// ppc64x: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]43, [$]4,"
// ppc64x: "MOVD [$]-1", "RLDC R[0-9]+, [$]43, [$]4,"
out[2] = 0x0FFFF80000000000
// ppc64x/power8: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]33, [$]63,"
// ppc64x/power9: "MOVD\t[$]-1", "RLDC\tR[0-9]+, [$]33, [$]63,"
// ppc64x/power10: "MOVD\t[$]-8589934591,"
// ppc64x/power8: "MOVD [$]-1", "RLDC R[0-9]+, [$]33, [$]63,"
// ppc64x/power9: "MOVD [$]-1", "RLDC R[0-9]+, [$]33, [$]63,"
// ppc64x/power10: "MOVD [$]-8589934591,"
out[3] = 0xFFFFFFFE00000001
return
}

34
test/codegen/copy.go
View file

@ -43,8 +43,8 @@ var x [256]byte
func moveDisjointStack32() {
var s [32]byte
// ppc64x:-".*memmove"
// ppc64x/power8:"LXVD2X",-"ADD",-"BC"
// ppc64x/power9:"LXV",-"LXVD2X",-"ADD",-"BC"
// ppc64x/power8:"LXVD2X" -"ADD" -"BC"
// ppc64x/power9:"LXV" -"LXVD2X" -"ADD" -"BC"
copy(s[:], x[:32])
runtime.KeepAlive(&s)
}
@ -52,8 +52,8 @@ func moveDisjointStack32() {
func moveDisjointStack64() {
var s [96]byte
// ppc64x:-".*memmove"
// ppc64x/power8:"LXVD2X","ADD","BC"
// ppc64x/power9:"LXV",-"LXVD2X",-"ADD",-"BC"
// ppc64x/power8:"LXVD2X" "ADD" "BC"
// ppc64x/power9:"LXV" -"LXVD2X" -"ADD" -"BC"
copy(s[:], x[:96])
runtime.KeepAlive(&s)
}
@ -64,7 +64,7 @@ func moveDisjointStack() {
// amd64:-".*memmove"
// ppc64x:-".*memmove"
// ppc64x/power8:"LXVD2X"
// ppc64x/power9:"LXV",-"LXVD2X"
// ppc64x/power9:"LXV" -"LXVD2X"
copy(s[:], x[:])
runtime.KeepAlive(&s)
}
@ -75,7 +75,7 @@ func moveDisjointArg(b *[256]byte) {
// amd64:-".*memmove"
// ppc64x:-".*memmove"
// ppc64x/power8:"LXVD2X"
// ppc64x/power9:"LXV",-"LXVD2X"
// ppc64x/power9:"LXV" -"LXVD2X"
copy(s[:], b[:])
runtime.KeepAlive(&s)
}
@ -85,7 +85,7 @@ func moveDisjointNoOverlap(a *[256]byte) {
// amd64:-".*memmove"
// ppc64x:-".*memmove"
// ppc64x/power8:"LXVD2X"
// ppc64x/power9:"LXV",-"LXVD2X"
// ppc64x/power9:"LXV" -"LXVD2X"
copy(a[:], a[128:])
}
@ -135,28 +135,28 @@ func moveArchLowering16(b []byte, x *[16]byte) {
// Check that no branches are generated when the pointers are [not] equal.
func ptrEqual() {
// amd64:-"JEQ",-"JNE"
// ppc64x:-"BEQ",-"BNE"
// s390x:-"BEQ",-"BNE"
// amd64:-"JEQ" -"JNE"
// ppc64x:-"BEQ" -"BNE"
// s390x:-"BEQ" -"BNE"
copy(x[:], x[:])
}
func ptrOneOffset() {
// amd64:-"JEQ",-"JNE"
// ppc64x:-"BEQ",-"BNE"
// s390x:-"BEQ",-"BNE"
// amd64:-"JEQ" -"JNE"
// ppc64x:-"BEQ" -"BNE"
// s390x:-"BEQ" -"BNE"
copy(x[1:], x[:])
}
func ptrBothOffset() {
// amd64:-"JEQ",-"JNE"
// ppc64x:-"BEQ",-"BNE"
// s390x:-"BEQ",-"BNE"
// amd64:-"JEQ" -"JNE"
// ppc64x:-"BEQ" -"BNE"
// s390x:-"BEQ" -"BNE"
copy(x[1:], x[2:])
}
// Verify #62698 on PPC64.
func noMaskOnCopy(a []int, s string, x int) int {
// ppc64x:-"MOVD\t$-1", -"AND"
// ppc64x:-"MOVD [$]-1", -"AND"
return a[x&^copy([]byte{}, s)]
}

1200
test/codegen/divmod.go Normal file
View file

File diff suppressed because it is too large Load diff

176
test/codegen/floats.go
View file

@ -6,6 +6,8 @@
package codegen
import "math"
// This file contains codegen tests related to arithmetic
// simplifications and optimizations on float types.
// For codegen tests on integer types, see arithmetic.go.
@ -15,42 +17,42 @@ package codegen
// --------------------- //
func Mul2(f float64) float64 {
// 386/sse2:"ADDSD",-"MULSD"
// amd64:"ADDSD",-"MULSD"
// arm/7:"ADDD",-"MULD"
// arm64:"FADDD",-"FMULD"
// loong64:"ADDD",-"MULD"
// ppc64x:"FADD",-"FMUL"
// riscv64:"FADDD",-"FMULD"
// 386/sse2:"ADDSD" -"MULSD"
// amd64:"ADDSD" -"MULSD"
// arm/7:"ADDD" -"MULD"
// arm64:"FADDD" -"FMULD"
// loong64:"ADDD" -"MULD"
// ppc64x:"FADD" -"FMUL"
// riscv64:"FADDD" -"FMULD"
return f * 2.0
}
func DivPow2(f1, f2, f3 float64) (float64, float64, float64) {
// 386/sse2:"MULSD",-"DIVSD"
// amd64:"MULSD",-"DIVSD"
// arm/7:"MULD",-"DIVD"
// arm64:"FMULD",-"FDIVD"
// loong64:"MULD",-"DIVD"
// ppc64x:"FMUL",-"FDIV"
// riscv64:"FMULD",-"FDIVD"
// 386/sse2:"MULSD" -"DIVSD"
// amd64:"MULSD" -"DIVSD"
// arm/7:"MULD" -"DIVD"
// arm64:"FMULD" -"FDIVD"
// loong64:"MULD" -"DIVD"
// ppc64x:"FMUL" -"FDIV"
// riscv64:"FMULD" -"FDIVD"
x := f1 / 16.0
// 386/sse2:"MULSD",-"DIVSD"
// amd64:"MULSD",-"DIVSD"
// arm/7:"MULD",-"DIVD"
// arm64:"FMULD",-"FDIVD"
// loong64:"MULD",-"DIVD"
// ppc64x:"FMUL",-"FDIVD"
// riscv64:"FMULD",-"FDIVD"
// 386/sse2:"MULSD" -"DIVSD"
// amd64:"MULSD" -"DIVSD"
// arm/7:"MULD" -"DIVD"
// arm64:"FMULD" -"FDIVD"
// loong64:"MULD" -"DIVD"
// ppc64x:"FMUL" -"FDIVD"
// riscv64:"FMULD" -"FDIVD"
y := f2 / 0.125
// 386/sse2:"ADDSD",-"DIVSD",-"MULSD"
// amd64:"ADDSD",-"DIVSD",-"MULSD"
// arm/7:"ADDD",-"MULD",-"DIVD"
// arm64:"FADDD",-"FMULD",-"FDIVD"
// loong64:"ADDD",-"MULD",-"DIVD"
// ppc64x:"FADD",-"FMUL",-"FDIV"
// riscv64:"FADDD",-"FMULD",-"FDIVD"
// 386/sse2:"ADDSD" -"DIVSD" -"MULSD"
// amd64:"ADDSD" -"DIVSD" -"MULSD"
// arm/7:"ADDD" -"MULD" -"DIVD"
// arm64:"FADDD" -"FMULD" -"FDIVD"
// loong64:"ADDD" -"MULD" -"DIVD"
// ppc64x:"FADD" -"FMUL" -"FDIV"
// riscv64:"FADDD" -"FMULD" -"FDIVD"
z := f3 / 0.5
return x, y, z
@ -73,67 +75,67 @@ func indexStore(b0 []float64, b1 float64, idx int) {
// ----------- //
func FusedAdd32(x, y, z float32) float32 {
// s390x:"FMADDS\t"
// ppc64x:"FMADDS\t"
// s390x:"FMADDS "
// ppc64x:"FMADDS "
// arm64:"FMADDS"
// loong64:"FMADDF\t"
// riscv64:"FMADDS\t"
// amd64/v3:"VFMADD231SS\t"
// loong64:"FMADDF "
// riscv64:"FMADDS "
// amd64/v3:"VFMADD231SS "
return x*y + z
}
func FusedSub32_a(x, y, z float32) float32 {
// s390x:"FMSUBS\t"
// ppc64x:"FMSUBS\t"
// riscv64:"FMSUBS\t"
// loong64:"FMSUBF\t"
// s390x:"FMSUBS "
// ppc64x:"FMSUBS "
// riscv64:"FMSUBS "
// loong64:"FMSUBF "
return x*y - z
}
func FusedSub32_b(x, y, z float32) float32 {
// arm64:"FMSUBS"
// loong64:"FNMSUBF\t"
// riscv64:"FNMSUBS\t"
// loong64:"FNMSUBF "
// riscv64:"FNMSUBS "
return z - x*y
}
func FusedAdd64(x, y, z float64) float64 {
// s390x:"FMADD\t"
// ppc64x:"FMADD\t"
// s390x:"FMADD "
// ppc64x:"FMADD "
// arm64:"FMADDD"
// loong64:"FMADDD\t"
// riscv64:"FMADDD\t"
// amd64/v3:"VFMADD231SD\t"
// loong64:"FMADDD "
// riscv64:"FMADDD "
// amd64/v3:"VFMADD231SD "
return x*y + z
}
func FusedSub64_a(x, y, z float64) float64 {
// s390x:"FMSUB\t"
// ppc64x:"FMSUB\t"
// riscv64:"FMSUBD\t"
// loong64:"FMSUBD\t"
// s390x:"FMSUB "
// ppc64x:"FMSUB "
// riscv64:"FMSUBD "
// loong64:"FMSUBD "
return x*y - z
}
func FusedSub64_b(x, y, z float64) float64 {
// arm64:"FMSUBD"
// loong64:"FNMSUBD\t"
// riscv64:"FNMSUBD\t"
// loong64:"FNMSUBD "
// riscv64:"FNMSUBD "
return z - x*y
}
func Cmp(f float64) bool {
// arm64:"FCMPD","(BGT|BLE|BMI|BPL)",-"CSET\tGT",-"CBZ"
// arm64:"FCMPD" "(BGT|BLE|BMI|BPL)" -"CSET GT" -"CBZ"
return f > 4 || f < -4
}
func CmpZero64(f float64) bool {
// s390x:"LTDBR",-"FCMPU"
// s390x:"LTDBR" -"FCMPU"
return f <= 0
}
func CmpZero32(f float32) bool {
// s390x:"LTEBR",-"CEBR"
// s390x:"LTEBR" -"CEBR"
return f <= 0
}
@ -218,43 +220,43 @@ func Float32Max(a, b float32) float32 {
// ------------------------ //
func Float32ConstantZero() float32 {
// arm64:"FMOVS\tZR,"
// arm64:"FMOVS ZR,"
return 0.0
}
func Float32ConstantChipFloat() float32 {
// arm64:"FMOVS\t[$]\\(2\\.25\\),"
// arm64:"FMOVS [$]\\(2\\.25\\),"
return 2.25
}
func Float32Constant() float32 {
// arm64:"FMOVS\t[$]f32\\.42440000\\(SB\\)"
// ppc64x/power8:"FMOVS\t[$]f32\\.42440000\\(SB\\)"
// ppc64x/power9:"FMOVS\t[$]f32\\.42440000\\(SB\\)"
// ppc64x/power10:"XXSPLTIDP\t[$]1111752704,"
// arm64:"FMOVS [$]f32\\.42440000\\(SB\\)"
// ppc64x/power8:"FMOVS [$]f32\\.42440000\\(SB\\)"
// ppc64x/power9:"FMOVS [$]f32\\.42440000\\(SB\\)"
// ppc64x/power10:"XXSPLTIDP [$]1111752704,"
return 49.0
}
func Float64ConstantZero() float64 {
// arm64:"FMOVD\tZR,"
// arm64:"FMOVD ZR,"
return 0.0
}
func Float64ConstantChipFloat() float64 {
// arm64:"FMOVD\t[$]\\(2\\.25\\),"
// arm64:"FMOVD [$]\\(2\\.25\\),"
return 2.25
}
func Float64Constant() float64 {
// arm64:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)"
// ppc64x/power8:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)"
// ppc64x/power9:"FMOVD\t[$]f64\\.4048800000000000\\(SB\\)"
// ppc64x/power10:"XXSPLTIDP\t[$]1111752704,"
// arm64:"FMOVD [$]f64\\.4048800000000000\\(SB\\)"
// ppc64x/power8:"FMOVD [$]f64\\.4048800000000000\\(SB\\)"
// ppc64x/power9:"FMOVD [$]f64\\.4048800000000000\\(SB\\)"
// ppc64x/power10:"XXSPLTIDP [$]1111752704,"
return 49.0
}
func Float32DenormalConstant() float32 {
// ppc64x:"FMOVS\t[$]f32\\.00400000\\(SB\\)"
// ppc64x:"FMOVS [$]f32\\.00400000\\(SB\\)"
return 0x1p-127
}
@ -262,16 +264,52 @@ func Float32DenormalConstant() float32 {
// denormal float32 value. On ppc64x, denormal values cannot
// be used with XXSPLTIDP.
func Float64DenormalFloat32Constant() float64 {
// ppc64x:"FMOVD\t[$]f64\\.3800000000000000\\(SB\\)"
// ppc64x:"FMOVD [$]f64\\.3800000000000000\\(SB\\)"
return 0x1p-127
}
func Float32ConstantStore(p *float32) {
// amd64:"MOVL\t[$]1085133554"
// amd64:"MOVL [$]1085133554"
// riscv64: "MOVF [$]f32.40add2f2"
*p = 5.432
}
func Float64ConstantStore(p *float64) {
// amd64:"MOVQ\t[$]4617801906721357038"
// amd64: "MOVQ [$]4617801906721357038"
// riscv64: "MOVD [$]f64.4015ba5e353f7cee"
*p = 5.432
}
// ------------------------ //
// Subnormal tests //
// ------------------------ //
func isSubnormal(x float64) bool {
// riscv64:"FCLASSD" -"FABSD"
return math.Abs(x) < 2.2250738585072014e-308
}
func isNormal(x float64) bool {
// riscv64:"FCLASSD" -"FABSD"
return math.Abs(x) >= 0x1p-1022
}
func isPosSubnormal(x float64) bool {
// riscv64:"FCLASSD"
return x > 0 && x < 2.2250738585072014e-308
}
func isNegSubnormal(x float64) bool {
// riscv64:"FCLASSD"
return x < 0 && x > -0x1p-1022
}
func isPosNormal(x float64) bool {
// riscv64:"FCLASSD"
return x >= 2.2250738585072014e-308
}
func isNegNormal(x float64) bool {
// riscv64:"FCLASSD"
return x <= -2.2250738585072014e-308
}

180
test/codegen/fuse.go
View file

@ -6,6 +6,8 @@
package codegen
import "math"
// Notes:
// - these examples use channels to provide a source of
// unknown values that cannot be optimized away
@ -17,57 +19,57 @@ package codegen
// ---------------------------------- //
func si1c(c <-chan int64) {
// amd64:"CMPQ\t.+, [$]256"
// s390x:"CLGIJ\t[$]12, R[0-9]+, [$]255"
// amd64:"CMPQ .+, [$]256"
// s390x:"CLGIJ [$]12, R[0-9]+, [$]255"
for x := <-c; x >= 0 && x < 256; x = <-c {
}
}
func si2c(c <-chan int32) {
// amd64:"CMPL\t.+, [$]256"
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255"
// amd64:"CMPL .+, [$]256"
// s390x:"CLIJ [$]12, R[0-9]+, [$]255"
for x := <-c; x >= 0 && x < 256; x = <-c {
}
}
func si3c(c <-chan int16) {
// amd64:"CMPW\t.+, [$]256"
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255"
// amd64:"CMPW .+, [$]256"
// s390x:"CLIJ [$]12, R[0-9]+, [$]255"
for x := <-c; x >= 0 && x < 256; x = <-c {
}
}
func si4c(c <-chan int8) {
// amd64:"CMPB\t.+, [$]10"
// s390x:"CLIJ\t[$]4, R[0-9]+, [$]10"
// amd64:"CMPB .+, [$]10"
// s390x:"CLIJ [$]4, R[0-9]+, [$]10"
for x := <-c; x >= 0 && x < 10; x = <-c {
}
}
func si5c(c <-chan int64) {
// amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5,"
// s390x:"CLGIJ\t[$]4, R[0-9]+, [$]251","ADD\t[$]-5,"
// amd64:"CMPQ .+, [$]251" "ADDQ [$]-5,"
// s390x:"CLGIJ [$]4, R[0-9]+, [$]251" "ADD [$]-5,"
for x := <-c; x < 256 && x > 4; x = <-c {
}
}
func si6c(c <-chan int32) {
// amd64:"CMPL\t.+, [$]255","DECL\t"
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255","ADDW\t[$]-1,"
// amd64:"CMPL .+, [$]255" "DECL "
// s390x:"CLIJ [$]12, R[0-9]+, [$]255" "ADDW [$]-1,"
for x := <-c; x > 0 && x <= 256; x = <-c {
}
}
func si7c(c <-chan int16) {
// amd64:"CMPW\t.+, [$]60","ADDL\t[$]10,"
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]60","ADDW\t[$]10,"
// amd64:"CMPW .+, [$]60" "ADDL [$]10,"
// s390x:"CLIJ [$]12, R[0-9]+, [$]60" "ADDW [$]10,"
for x := <-c; x >= -10 && x <= 50; x = <-c {
}
}
func si8c(c <-chan int8) {
// amd64:"CMPB\t.+, [$]126","ADDL\t[$]126,"
// s390x:"CLIJ\t[$]4, R[0-9]+, [$]126","ADDW\t[$]126,"
// amd64:"CMPB .+, [$]126" "ADDL [$]126,"
// s390x:"CLIJ [$]4, R[0-9]+, [$]126" "ADDW [$]126,"
for x := <-c; x >= -126 && x < 0; x = <-c {
}
}
@ -77,57 +79,57 @@ func si8c(c <-chan int8) {
// ---------------------------------- //
func si1d(c <-chan int64) {
// amd64:"CMPQ\t.+, [$]256"
// s390x:"CLGIJ\t[$]2, R[0-9]+, [$]255"
// amd64:"CMPQ .+, [$]256"
// s390x:"CLGIJ [$]2, R[0-9]+, [$]255"
for x := <-c; x < 0 || x >= 256; x = <-c {
}
}
func si2d(c <-chan int32) {
// amd64:"CMPL\t.+, [$]256"
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]255"
// amd64:"CMPL .+, [$]256"
// s390x:"CLIJ [$]2, R[0-9]+, [$]255"
for x := <-c; x < 0 || x >= 256; x = <-c {
}
}
func si3d(c <-chan int16) {
// amd64:"CMPW\t.+, [$]256"
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]255"
// amd64:"CMPW .+, [$]256"
// s390x:"CLIJ [$]2, R[0-9]+, [$]255"
for x := <-c; x < 0 || x >= 256; x = <-c {
}
}
func si4d(c <-chan int8) {
// amd64:"CMPB\t.+, [$]10"
// s390x:"CLIJ\t[$]10, R[0-9]+, [$]10"
// amd64:"CMPB .+, [$]10"
// s390x:"CLIJ [$]10, R[0-9]+, [$]10"
for x := <-c; x < 0 || x >= 10; x = <-c {
}
}
func si5d(c <-chan int64) {
// amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5,"
// s390x:"CLGIJ\t[$]10, R[0-9]+, [$]251","ADD\t[$]-5,"
// amd64:"CMPQ .+, [$]251" "ADDQ [$]-5,"
// s390x:"CLGIJ [$]10, R[0-9]+, [$]251" "ADD [$]-5,"
for x := <-c; x >= 256 || x <= 4; x = <-c {
}
}
func si6d(c <-chan int32) {
// amd64:"CMPL\t.+, [$]255","DECL\t"
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]255","ADDW\t[$]-1,"
// amd64:"CMPL .+, [$]255" "DECL "
// s390x:"CLIJ [$]2, R[0-9]+, [$]255" "ADDW [$]-1,"
for x := <-c; x <= 0 || x > 256; x = <-c {
}
}
func si7d(c <-chan int16) {
// amd64:"CMPW\t.+, [$]60","ADDL\t[$]10,"
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]60","ADDW\t[$]10,"
// amd64:"CMPW .+, [$]60" "ADDL [$]10,"
// s390x:"CLIJ [$]2, R[0-9]+, [$]60" "ADDW [$]10,"
for x := <-c; x < -10 || x > 50; x = <-c {
}
}
func si8d(c <-chan int8) {
// amd64:"CMPB\t.+, [$]126","ADDL\t[$]126,"
// s390x:"CLIJ\t[$]10, R[0-9]+, [$]126","ADDW\t[$]126,"
// amd64:"CMPB .+, [$]126" "ADDL [$]126,"
// s390x:"CLIJ [$]10, R[0-9]+, [$]126" "ADDW [$]126,"
for x := <-c; x < -126 || x >= 0; x = <-c {
}
}
@ -137,29 +139,29 @@ func si8d(c <-chan int8) {
// ------------------------------------ //
func ui1c(c <-chan uint64) {
// amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5,"
// s390x:"CLGIJ\t[$]4, R[0-9]+, [$]251","ADD\t[$]-5,"
// amd64:"CMPQ .+, [$]251" "ADDQ [$]-5,"
// s390x:"CLGIJ [$]4, R[0-9]+, [$]251" "ADD [$]-5,"
for x := <-c; x < 256 && x > 4; x = <-c {
}
}
func ui2c(c <-chan uint32) {
// amd64:"CMPL\t.+, [$]255","DECL\t"
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]255","ADDW\t[$]-1,"
// amd64:"CMPL .+, [$]255" "DECL "
// s390x:"CLIJ [$]12, R[0-9]+, [$]255" "ADDW [$]-1,"
for x := <-c; x > 0 && x <= 256; x = <-c {
}
}
func ui3c(c <-chan uint16) {
// amd64:"CMPW\t.+, [$]40","ADDL\t[$]-10,"
// s390x:"CLIJ\t[$]12, R[0-9]+, [$]40","ADDW\t[$]-10,"
// amd64:"CMPW .+, [$]40" "ADDL [$]-10,"
// s390x:"CLIJ [$]12, R[0-9]+, [$]40" "ADDW [$]-10,"
for x := <-c; x >= 10 && x <= 50; x = <-c {
}
}
func ui4c(c <-chan uint8) {
// amd64:"CMPB\t.+, [$]2","ADDL\t[$]-126,"
// s390x:"CLIJ\t[$]4, R[0-9]+, [$]2","ADDW\t[$]-126,"
// amd64:"CMPB .+, [$]2" "ADDL [$]-126,"
// s390x:"CLIJ [$]4, R[0-9]+, [$]2" "ADDW [$]-126,"
for x := <-c; x >= 126 && x < 128; x = <-c {
}
}
@ -169,33 +171,111 @@ func ui4c(c <-chan uint8) {
// ------------------------------------ //
func ui1d(c <-chan uint64) {
// amd64:"CMPQ\t.+, [$]251","ADDQ\t[$]-5,"
// s390x:"CLGIJ\t[$]10, R[0-9]+, [$]251","ADD\t[$]-5,"
// amd64:"CMPQ .+, [$]251" "ADDQ [$]-5,"
// s390x:"CLGIJ [$]10, R[0-9]+, [$]251" "ADD [$]-5,"
for x := <-c; x >= 256 || x <= 4; x = <-c {
}
}
func ui2d(c <-chan uint32) {
// amd64:"CMPL\t.+, [$]254","ADDL\t[$]-2,"
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]254","ADDW\t[$]-2,"
// amd64:"CMPL .+, [$]254" "ADDL [$]-2,"
// s390x:"CLIJ [$]2, R[0-9]+, [$]254" "ADDW [$]-2,"
for x := <-c; x <= 1 || x > 256; x = <-c {
}
}
func ui3d(c <-chan uint16) {
// amd64:"CMPW\t.+, [$]40","ADDL\t[$]-10,"
// s390x:"CLIJ\t[$]2, R[0-9]+, [$]40","ADDW\t[$]-10,"
// amd64:"CMPW .+, [$]40" "ADDL [$]-10,"
// s390x:"CLIJ [$]2, R[0-9]+, [$]40" "ADDW [$]-10,"
for x := <-c; x < 10 || x > 50; x = <-c {
}
}
func ui4d(c <-chan uint8) {
// amd64:"CMPB\t.+, [$]2","ADDL\t[$]-126,"
// s390x:"CLIJ\t[$]10, R[0-9]+, [$]2","ADDW\t[$]-126,"
// amd64:"CMPB .+, [$]2" "ADDL [$]-126,"
// s390x:"CLIJ [$]10, R[0-9]+, [$]2" "ADDW [$]-126,"
for x := <-c; x < 126 || x >= 128; x = <-c {
}
}
// -------------------------------------//
// merge NaN checks //
// ------------------------------------ //
func f64NaNOrPosInf(c <-chan float64) {
// This test assumes IsInf(x, 1) is implemented as x > MaxFloat rather than x == Inf(1).
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
// riscv64:"FCLASSD" -"FLED" -"FLTD" -"FNED" -"FEQD"
for x := <-c; math.IsNaN(x) || math.IsInf(x, 1); x = <-c {
}
}
func f64NaNOrNegInf(c <-chan float64) {
// This test assumes IsInf(x, -1) is implemented as x < -MaxFloat rather than x == Inf(-1).
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
// riscv64:"FCLASSD" -"FLED" -"FLTD" -"FNED" -"FEQD"
for x := <-c; math.IsNaN(x) || math.IsInf(x, -1); x = <-c {
}
}
func f64NaNOrLtOne(c <-chan float64) {
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
// riscv64:"FLED" -"FLTD" -"FNED" -"FEQD"
for x := <-c; math.IsNaN(x) || x < 1; x = <-c {
}
}
func f64NaNOrLteOne(c <-chan float64) {
// amd64:"JLS" -"JNE" -"JPS" -"JPC"
// riscv64:"FLTD" -"FLED" -"FNED" -"FEQD"
for x := <-c; x <= 1 || math.IsNaN(x); x = <-c {
}
}
func f64NaNOrGtOne(c <-chan float64) {
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
// riscv64:"FLED" -"FLTD" -"FNED" -"FEQD"
for x := <-c; math.IsNaN(x) || x > 1; x = <-c {
}
}
func f64NaNOrGteOne(c <-chan float64) {
// amd64:"JLS" -"JNE" -"JPS" -"JPC"
// riscv64:"FLTD" -"FLED" -"FNED" -"FEQD"
for x := <-c; x >= 1 || math.IsNaN(x); x = <-c {
}
}
func f32NaNOrLtOne(c <-chan float32) {
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
// riscv64:"FLES" -"FLTS" -"FNES" -"FEQS"
for x := <-c; x < 1 || x != x; x = <-c {
}
}
func f32NaNOrLteOne(c <-chan float32) {
// amd64:"JLS" -"JNE" -"JPS" -"JPC"
// riscv64:"FLTS" -"FLES" -"FNES" -"FEQS"
for x := <-c; x != x || x <= 1; x = <-c {
}
}
func f32NaNOrGtOne(c <-chan float32) {
// amd64:"JCS" -"JNE" -"JPS" -"JPC"
// riscv64:"FLES" -"FLTS" -"FNES" -"FEQS"
for x := <-c; x > 1 || x != x; x = <-c {
}
}
func f32NaNOrGteOne(c <-chan float32) {
// amd64:"JLS" -"JNE" -"JPS" -"JPC"
// riscv64:"FLTS" -"FLES" -"FNES" -"FEQS"
for x := <-c; x != x || x >= 1; x = <-c {
}
}
// ------------------------------------ //
// regressions //
// ------------------------------------ //
@ -211,8 +291,8 @@ func lt20(x uint64) bool {
func issue74915(c <-chan uint64) {
// Check that the optimization is not blocked by function inlining.
// amd64:"CMPQ\t.+, [$]16","ADDQ\t[$]-4,"
// s390x:"CLGIJ\t[$]4, R[0-9]+, [$]16","ADD\t[$]-4,"
// amd64:"CMPQ .+, [$]16" "ADDQ [$]-4,"
// s390x:"CLGIJ [$]4, R[0-9]+, [$]16" "ADD [$]-4,"
for x := <-c; gte4(x) && lt20(x); x = <-c {
}
}

14
test/codegen/ifaces.go
View file

@ -21,20 +21,20 @@ func NopConvertGeneric[T any](x T) T {
var NopConvertGenericIface = NopConvertGeneric[I]
func ConvToM(x any) I {
// amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(.*\)`,`MOVQ\t8\(.*\)(.*\*1)`
// arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU`,`MOVD\t\(R.*\)\(R.*\)`
// amd64:`CALL runtime.typeAssert`,`MOVL 16\(.*\)`,`MOVQ 8\(.*\)(.*\*1)`
// arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU`,`MOVD \(R.*\)\(R.*\)`
return x.(I)
}
func e1(x any, y *int) bool {
// amd64:-`.*faceeq`,`SETEQ`
// arm64:-`.*faceeq`,`CSET\tEQ`
// arm64:-`.*faceeq`,`CSET EQ`
return x == y
}
func e2(x any, y *int) bool {
// amd64:-`.*faceeq`,`SETEQ`
// arm64:-`.*faceeq`,`CSET\tEQ`
// arm64:-`.*faceeq`,`CSET EQ`
return y == x
}
@ -42,7 +42,7 @@ type E *int
func e3(x any, y E) bool {
// amd64:-`.*faceeq`,`SETEQ`
// arm64:-`.*faceeq`,`CSET\tEQ`
// arm64:-`.*faceeq`,`CSET EQ`
return x == y
}
@ -52,12 +52,12 @@ func (t *T) M() {}
func i1(x I, y *T) bool {
// amd64:-`.*faceeq`,`SETEQ`
// arm64:-`.*faceeq`,`CSET\tEQ`
// arm64:-`.*faceeq`,`CSET EQ`
return x == y
}
func i2(x I, y *T) bool {
// amd64:-`.*faceeq`,`SETEQ`
// arm64:-`.*faceeq`,`CSET\tEQ`
// arm64:-`.*faceeq`,`CSET EQ`
return y == x
}

4
test/codegen/issue25378.go
View file

@ -14,9 +14,9 @@ var wsp = [256]bool{
}
func zeroExtArgByte(ch [2]byte) bool {
return wsp[ch[0]] // amd64:-"MOVBLZX\t..,.."
return wsp[ch[0]] // amd64:-"MOVBLZX ..,.."
}
func zeroExtArgUint16(ch [2]uint16) bool {
return wsp[ch[0]] // amd64:-"MOVWLZX\t..,.."
return wsp[ch[0]] // amd64:-"MOVWLZX ..,.."
}

10
test/codegen/issue52635.go
View file

@ -17,31 +17,31 @@ type T struct {
func (t *T) f() {
// amd64:-".*runtime.memclrNoHeapPointers"
// amd64:`MOVUPS\tX15,`
// amd64:`MOVUPS X15,`
for i := range t.a {
t.a[i] = 0
}
// amd64:-".*runtime.memclrNoHeapPointers"
// amd64:`MOVUPS\tX15,`
// amd64:`MOVUPS X15,`
for i := range *t.a {
t.a[i] = 0
}
// amd64:-".*runtime.memclrNoHeapPointers"
// amd64:`MOVUPS\tX15,`
// amd64:`MOVUPS X15,`
for i := range t.a {
(*t.a)[i] = 0
}
// amd64:-".*runtime.memclrNoHeapPointers"
// amd64:`MOVUPS\tX15,`
// amd64:`MOVUPS X15,`
for i := range *t.a {
(*t.a)[i] = 0
}
// amd64:-".*runtime.memclrNoHeapPointers"
// amd64:`MOVUPS\tX15,`
// amd64:`MOVUPS X15,`
for i := range t.b {
t.b[i] = 0
}

4
test/codegen/issue56440.go
View file

@ -13,7 +13,7 @@ package codegen
func f(x []int) int {
s := make([]int, 3)
s = append(s, 4, 5)
// amd64:`MOVQ\t40\(.*\),`
// amd64:`MOVQ 40\(.*\),`
return x[len(s)]
}
@ -26,7 +26,7 @@ func g(x []int, p *bool) int {
}
s = append(s, 4, 5)
if *p {
// amd64:`MOVQ\t40\(.*\),`
// amd64:`MOVQ 40\(.*\),`
return x[len(s)]
}
}

14
test/codegen/issue60324.go
View file

@ -7,30 +7,30 @@
package codegen
func main() {
// amd64:"LEAQ\tcommand-line-arguments\\.main\\.f\\.g\\.h\\.func3"
// amd64:"LEAQ command-line-arguments\\.main\\.f\\.g\\.h\\.func3"
f(1)()
// amd64:"LEAQ\tcommand-line-arguments\\.main\\.g\\.h\\.func2"
// amd64:"LEAQ command-line-arguments\\.main\\.g\\.h\\.func2"
g(2)()
// amd64:"LEAQ\tcommand-line-arguments\\.main\\.h\\.func1"
// amd64:"LEAQ command-line-arguments\\.main\\.h\\.func1"
h(3)()
// amd64:"LEAQ\tcommand-line-arguments\\.main\\.f\\.g\\.h\\.func4"
// amd64:"LEAQ command-line-arguments\\.main\\.f\\.g\\.h\\.func4"
f(4)()
}
func f(x int) func() {
// amd64:"LEAQ\tcommand-line-arguments\\.f\\.g\\.h\\.func1"
// amd64:"LEAQ command-line-arguments\\.f\\.g\\.h\\.func1"
return g(x)
}
func g(x int) func() {
// amd64:"LEAQ\tcommand-line-arguments\\.g\\.h\\.func1"
// amd64:"LEAQ command-line-arguments\\.g\\.h\\.func1"
return h(x)
}
func h(x int) func() {
// amd64:"LEAQ\tcommand-line-arguments\\.h\\.func1"
// amd64:"LEAQ command-line-arguments\\.h\\.func1"
return func() { recover() }
}

16
test/codegen/issue74485.go
View file

@ -7,41 +7,41 @@
package codegen
func divUint64(b uint64) uint64 {
// amd64:"SHRQ [$]63, AX"
// amd64:"SHRQ [$]63, AX"
return b / 9223372036854775808
}
func divUint32(b uint32) uint32 {
// amd64:"SHRL [$]31, AX"
// amd64:"SHRL [$]31, AX"
return b / 2147483648
}
func divUint16(b uint16) uint16 {
// amd64:"SHRW [$]15, AX"
// amd64:"SHRW [$]15, AX"
return b / 32768
}
func divUint8(b uint8) uint8 {
// amd64:"SHRB [$]7, AL"
// amd64:"SHRB [$]7, AL"
return b / 128
}
func modUint64(b uint64) uint64 {
// amd64:"BTRQ [$]63, AX"
// amd64:"BTRQ [$]63, AX"
return b % 9223372036854775808
}
func modUint32(b uint32) uint32 {
// amd64:"ANDL [$]2147483647, AX"
// amd64:"ANDL [$]2147483647, AX"
return b % 2147483648
}
func modUint16(b uint16) uint16 {
// amd64:"ANDL [$]32767, AX"
// amd64:"ANDL [$]32767, AX"
return b % 32768
}
func modUint8(b uint8) uint8 {
// amd64:"ANDL [$]127, AX"
// amd64:"ANDL [$]127, AX"
return b % 128
}

2
test/codegen/load_type_from_itab.go
View file

@ -19,6 +19,6 @@ func (*Impl) A() {}
func main() {
var a M = &Impl{}
// amd64:`LEAQ\ttype:.*Impl`
// amd64:`LEAQ type:.*Impl`
a.(A).A()
}

4
test/codegen/logic.go
View file

@ -28,14 +28,14 @@ func ornot(x, y int) int {
// Verify that (OR (NOT x) (NOT y)) rewrites to (NOT (AND x y))
func orDemorgans(x, y int) int {
// amd64:"AND",-"OR"
// amd64:"AND" -"OR"
z := ^x | ^y
return z
}
// Verify that (AND (NOT x) (NOT y)) rewrites to (NOT (OR x y))
func andDemorgans(x, y int) int {
// amd64:"OR",-"AND"
// amd64:"OR" -"AND"
z := ^x & ^y
return z
}

30
test/codegen/maps.go
View file

@ -16,12 +16,12 @@ package codegen
// Direct use of constants in fast map access calls (Issue #19015).
func AccessInt1(m map[int]int) int {
// amd64:"MOV[LQ]\t[$]5"
// amd64:"MOV[LQ] [$]5"
return m[5]
}
func AccessInt2(m map[int]int) bool {
// amd64:"MOV[LQ]\t[$]5"
// amd64:"MOV[LQ] [$]5"
_, ok := m[5]
return ok
}
@ -37,6 +37,28 @@ func AccessString2(m map[string]int) bool {
return ok
}
func AccessStringIntArray2(m map[string][16]int, k string) bool {
// amd64:-"MOVUPS"
_, ok := m[k]
return ok
}
type Struct struct {
A, B, C, D, E, F, G, H, I, J int
}
func AccessStringStruct2(m map[string]Struct, k string) bool {
// amd64:-"MOVUPS"
_, ok := m[k]
return ok
}
func AccessIntArrayLarge2(m map[int][512]int, k int) bool {
// amd64:-"REP",-"MOVSQ"
_, ok := m[k]
return ok
}
// ------------------- //
// String Conversion //
// ------------------- //
@ -147,7 +169,7 @@ func MapClearSideEffect(m map[int]int) int {
func MapLiteralSizing(x int) (map[int]int, map[int]int) {
// This is tested for internal/abi/maps.go:MapBucketCountBits={3,4,5}
// amd64:"MOVL\t[$]33,"
// amd64:"MOVL [$]33,"
m := map[int]int{
0: 0,
1: 1,
@ -183,7 +205,7 @@ func MapLiteralSizing(x int) (map[int]int, map[int]int) {
31: 32,
32: 32,
}
// amd64:"MOVL\t[$]33,"
// amd64:"MOVL [$]33,"
n := map[int]int{
0: 0,
1: 1,

161
test/codegen/math.go
View file

@ -1,4 +1,4 @@
// asmcheck
// asmcheck -gcflags=-d=converthash=qy
// Copyright 2018 The Go Authors. All rights reserved.
// Use of this source code is governed by a BSD-style
@ -12,37 +12,37 @@ var sink64 [8]float64
func approx(x float64) {
// amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41"
// amd64:"ROUNDSD\t[$]2"
// s390x:"FIDBR\t[$]6"
// amd64:"ROUNDSD [$]2"
// s390x:"FIDBR [$]6"
// arm64:"FRINTPD"
// ppc64x:"FRIP"
// wasm:"F64Ceil"
sink64[0] = math.Ceil(x)
// amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41"
// amd64:"ROUNDSD\t[$]1"
// s390x:"FIDBR\t[$]7"
// amd64:"ROUNDSD [$]1"
// s390x:"FIDBR [$]7"
// arm64:"FRINTMD"
// ppc64x:"FRIM"
// wasm:"F64Floor"
sink64[1] = math.Floor(x)
// s390x:"FIDBR\t[$]1"
// s390x:"FIDBR [$]1"
// arm64:"FRINTAD"
// ppc64x:"FRIN"
sink64[2] = math.Round(x)
// amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41"
// amd64:"ROUNDSD\t[$]3"
// s390x:"FIDBR\t[$]5"
// amd64:"ROUNDSD [$]3"
// s390x:"FIDBR [$]5"
// arm64:"FRINTZD"
// ppc64x:"FRIZ"
// wasm:"F64Trunc"
sink64[3] = math.Trunc(x)
// amd64/v2:-".*x86HasSSE41" amd64/v3:-".*x86HasSSE41"
// amd64:"ROUNDSD\t[$]0"
// s390x:"FIDBR\t[$]4"
// amd64:"ROUNDSD [$]0"
// s390x:"FIDBR [$]4"
// arm64:"FRINTND"
// wasm:"F64Nearest"
sink64[4] = math.RoundToEven(x)
@ -78,43 +78,43 @@ func sqrt32(x float32) float32 {
// Check that it's using integer registers
func abs(x, y float64) {
// amd64:"BTRQ\t[$]63"
// arm64:"FABSD\t"
// loong64:"ABSD\t"
// s390x:"LPDFR\t",-"MOVD\t" (no integer load/store)
// ppc64x:"FABS\t"
// riscv64:"FABSD\t"
// amd64:"BTRQ [$]63"
// arm64:"FABSD "
// loong64:"ABSD "
// s390x:"LPDFR " -"MOVD " (no integer load/store)
// ppc64x:"FABS "
// riscv64:"FABSD "
// wasm:"F64Abs"
// arm/6:"ABSD\t"
// mips64/hardfloat:"ABSD\t"
// mips/hardfloat:"ABSD\t"
// arm/6:"ABSD "
// mips64/hardfloat:"ABSD "
// mips/hardfloat:"ABSD "
sink64[0] = math.Abs(x)
// amd64:"BTRQ\t[$]63","PXOR" (TODO: this should be BTSQ)
// s390x:"LNDFR\t",-"MOVD\t" (no integer load/store)
// ppc64x:"FNABS\t"
// amd64:"BTRQ [$]63" "PXOR" (TODO: this should be BTSQ)
// s390x:"LNDFR " -"MOVD " (no integer load/store)
// ppc64x:"FNABS "
sink64[1] = -math.Abs(y)
}
// Check that it's using integer registers
func abs32(x float32) float32 {
// s390x:"LPDFR",-"LDEBR",-"LEDBR" (no float64 conversion)
// s390x:"LPDFR" -"LDEBR" -"LEDBR" (no float64 conversion)
return float32(math.Abs(float64(x)))
}
// Check that it's using integer registers
func copysign(a, b, c float64) {
// amd64:"BTRQ\t[$]63","ANDQ","ORQ"
// amd64:"BTRQ [$]63" "ANDQ" "ORQ"
// loong64:"FCOPYSGD"
// s390x:"CPSDR",-"MOVD" (no integer load/store)
// s390x:"CPSDR" -"MOVD" (no integer load/store)
// ppc64x:"FCPSGN"
// riscv64:"FSGNJD"
// wasm:"F64Copysign"
sink64[0] = math.Copysign(a, b)
// amd64:"BTSQ\t[$]63"
// amd64:"BTSQ [$]63"
// loong64:"FCOPYSGD"
// s390x:"LNDFR\t",-"MOVD\t" (no integer load/store)
// s390x:"LNDFR " -"MOVD " (no integer load/store)
// ppc64x:"FCPSGN"
// riscv64:"FSGNJD"
// arm64:"ORR", -"AND"
@ -122,12 +122,12 @@ func copysign(a, b, c float64) {
// Like math.Copysign(c, -1), but with integer operations. Useful
// for platforms that have a copysign opcode to see if it's detected.
// s390x:"LNDFR\t",-"MOVD\t" (no integer load/store)
// s390x:"LNDFR " -"MOVD " (no integer load/store)
sink64[2] = math.Float64frombits(math.Float64bits(a) | 1<<63)
// amd64:"ANDQ","ORQ"
// amd64:"ANDQ" "ORQ"
// loong64:"FCOPYSGD"
// s390x:"CPSDR\t",-"MOVD\t" (no integer load/store)
// s390x:"CPSDR " -"MOVD " (no integer load/store)
// ppc64x:"FCPSGN"
// riscv64:"FSGNJD"
sink64[3] = math.Copysign(-1, c)
@ -151,12 +151,12 @@ func fms(x, y, z float64) float64 {
}
func fnms(x, y, z float64) float64 {
// riscv64:"FNMSUBD",-"FNMADDD"
// riscv64:"FNMSUBD" -"FNMADDD"
return math.FMA(-x, y, z)
}
func fnma(x, y, z float64) float64 {
// riscv64:"FNMADDD",-"FNMSUBD"
// riscv64:"FNMADDD" -"FNMSUBD"
return math.FMA(x, -y, -z)
}
@ -221,39 +221,39 @@ func isNotNegInfCmp(x float64) bool {
}
func fromFloat64(f64 float64) uint64 {
// amd64:"MOVQ\tX.*, [^X].*"
// arm64:"FMOVD\tF.*, R.*"
// loong64:"MOVV\tF.*, R.*"
// amd64:"MOVQ X.*, [^X].*"
// arm64:"FMOVD F.*, R.*"
// loong64:"MOVV F.*, R.*"
// ppc64x:"MFVSRD"
// mips64/hardfloat:"MOVV\tF.*, R.*"
// mips64/hardfloat:"MOVV F.*, R.*"
// riscv64:"FMVXD"
return math.Float64bits(f64+1) + 1
}
func fromFloat32(f32 float32) uint32 {
// amd64:"MOVL\tX.*, [^X].*"
// arm64:"FMOVS\tF.*, R.*"
// loong64:"MOVW\tF.*, R.*"
// mips64/hardfloat:"MOVW\tF.*, R.*"
// amd64:"MOVL X.*, [^X].*"
// arm64:"FMOVS F.*, R.*"
// loong64:"MOVW F.*, R.*"
// mips64/hardfloat:"MOVW F.*, R.*"
// riscv64:"FMVXW"
return math.Float32bits(f32+1) + 1
}
func toFloat64(u64 uint64) float64 {
// amd64:"MOVQ\t[^X].*, X.*"
// arm64:"FMOVD\tR.*, F.*"
// loong64:"MOVV\tR.*, F.*"
// amd64:"MOVQ [^X].*, X.*"
// arm64:"FMOVD R.*, F.*"
// loong64:"MOVV R.*, F.*"
// ppc64x:"MTVSRD"
// mips64/hardfloat:"MOVV\tR.*, F.*"
// mips64/hardfloat:"MOVV R.*, F.*"
// riscv64:"FMVDX"
return math.Float64frombits(u64+1) + 1
}
func toFloat32(u32 uint32) float32 {
// amd64:"MOVL\t[^X].*, X.*"
// arm64:"FMOVS\tR.*, F.*"
// loong64:"MOVW\tR.*, F.*"
// mips64/hardfloat:"MOVW\tR.*, F.*"
// amd64:"MOVL [^X].*, X.*"
// arm64:"FMOVS R.*, F.*"
// loong64:"MOVW R.*, F.*"
// mips64/hardfloat:"MOVW R.*, F.*"
// riscv64:"FMVWX"
return math.Float32frombits(u32+1) + 1
}
@ -262,14 +262,14 @@ func toFloat32(u32 uint32) float32 {
// are evaluated at compile-time
func constantCheck64() bool {
// amd64:"(MOVB\t[$]0)|(XORL\t[A-Z][A-Z0-9]+, [A-Z][A-Z0-9]+)",-"FCMP",-"MOVB\t[$]1"
// s390x:"MOV(B|BZ|D)\t[$]0,",-"FCMPU",-"MOV(B|BZ|D)\t[$]1,"
// amd64:"(MOVB [$]0)|(XORL [A-Z][A-Z0-9]+, [A-Z][A-Z0-9]+)" -"FCMP" -"MOVB [$]1"
// s390x:"MOV(B|BZ|D) [$]0," -"FCMPU" -"MOV(B|BZ|D) [$]1,"
return 0.5 == float64(uint32(1)) || 1.5 > float64(uint64(1<<63))
}
func constantCheck32() bool {
// amd64:"MOV(B|L)\t[$]1",-"FCMP",-"MOV(B|L)\t[$]0"
// s390x:"MOV(B|BZ|D)\t[$]1,",-"FCMPU",-"MOV(B|BZ|D)\t[$]0,"
// amd64:"MOV(B|L) [$]1" -"FCMP" -"MOV(B|L) [$]0"
// s390x:"MOV(B|BZ|D) [$]1," -"FCMPU" -"MOV(B|BZ|D) [$]0,"
return float32(0.5) <= float32(int64(1)) && float32(1.5) >= float32(int32(-1<<31))
}
@ -277,12 +277,12 @@ func constantCheck32() bool {
// at compile-time
func constantConvert32(x float32) float32 {
// amd64:"MOVSS\t[$]f32.3f800000\\(SB\\)"
// s390x:"FMOVS\t[$]f32.3f800000\\(SB\\)"
// ppc64x/power8:"FMOVS\t[$]f32.3f800000\\(SB\\)"
// ppc64x/power9:"FMOVS\t[$]f32.3f800000\\(SB\\)"
// ppc64x/power10:"XXSPLTIDP\t[$]1065353216, VS0"
// arm64:"FMOVS\t[$]\\(1.0\\)"
// amd64:"MOVSS [$]f32.3f800000\\(SB\\)"
// s390x:"FMOVS [$]f32.3f800000\\(SB\\)"
// ppc64x/power8:"FMOVS [$]f32.3f800000\\(SB\\)"
// ppc64x/power9:"FMOVS [$]f32.3f800000\\(SB\\)"
// ppc64x/power10:"XXSPLTIDP [$]1065353216, VS0"
// arm64:"FMOVS [$]\\(1.0\\)"
if x > math.Float32frombits(0x3f800000) {
return -x
}
@ -330,3 +330,48 @@ func nanGenerate32() float32 {
// amd64/v3:"VFMADD231SS"
return z0 + z1
}
func outOfBoundsConv(i32 *[2]int32, u32 *[2]uint32, i64 *[2]int64, u64 *[2]uint64) {
// arm64: "FCVTZSDW"
// amd64: "CVTTSD2SL", "CVTSD2SS"
i32[0] = int32(two40())
// arm64: "FCVTZSDW"
// amd64: "CVTTSD2SL", "CVTSD2SS"
i32[1] = int32(-two40())
// arm64: "FCVTZSDW"
// amd64: "CVTTSD2SL", "CVTSD2SS"
u32[0] = uint32(two41())
// on arm64, this uses an explicit <0 comparison, so it constant folds.
// on amd64, this uses an explicit <0 comparison, so it constant folds.
// amd64: "MOVL [$]0,"
u32[1] = uint32(minus1())
// arm64: "FCVTZSD"
// amd64: "CVTTSD2SQ"
i64[0] = int64(two80())
// arm64: "FCVTZSD"
// amd64: "CVTTSD2SQ"
i64[1] = int64(-two80())
// arm64: "FCVTZUD"
// amd64: "CVTTSD2SQ"
u64[0] = uint64(two81())
// arm64: "FCVTZUD"
// on amd64, this uses an explicit <0 comparison, so it constant folds.
// amd64: "MOVQ [$]0,"
u64[1] = uint64(minus1())
}
func two40() float64 {
return 1 << 40
}
func two41() float64 {
return 1 << 41
}
func two80() float64 {
return 1 << 80
}
func two81() float64 {
return 1 << 81
}
func minus1() float64 {
return -1
}

441
test/codegen/mathbits.go
View file

@ -20,10 +20,10 @@ func LeadingZeros(n uint) int {
// amd64/v3:"LZCNTQ", -"BSRQ"
// arm64:"CLZ"
// arm:"CLZ"
// loong64:"CLZV",-"SUB"
// loong64:"CLZV" -"SUB"
// mips:"CLZ"
// ppc64x:"CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t",-"SUB"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " -"SUB"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.LeadingZeros(n)
@ -34,52 +34,52 @@ func LeadingZeros64(n uint64) int {
// amd64/v3:"LZCNTQ", -"BSRQ"
// arm:"CLZ"
// arm64:"CLZ"
// loong64:"CLZV",-"SUB"
// loong64:"CLZV" -"SUB"
// mips:"CLZ"
// ppc64x:"CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t",-"ADDI"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " -"ADDI"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.LeadingZeros64(n)
}
func LeadingZeros32(n uint32) int {
// amd64/v1,amd64/v2:"BSRQ","LEAQ",-"CMOVQEQ"
// amd64/v3: "LZCNTL",- "BSRL"
// amd64/v1,amd64/v2:"BSRQ" "LEAQ" -"CMOVQEQ"
// amd64/v3: "LZCNTL" - "BSRL"
// arm:"CLZ"
// arm64:"CLZW"
// loong64:"CLZW",-"SUB"
// loong64:"CLZW" -"SUB"
// mips:"CLZ"
// ppc64x:"CNTLZW"
// riscv64/rva22u64,riscv64/rva23u64:"CLZW",-"ADDI"
// riscv64/rva22u64,riscv64/rva23u64:"CLZW" -"ADDI"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.LeadingZeros32(n)
}
func LeadingZeros16(n uint16) int {
// amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ"
// amd64/v3: "LZCNTL",- "BSRL"
// amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ"
// amd64/v3: "LZCNTL" - "BSRL"
// arm64:"CLZ"
// arm:"CLZ"
// loong64:"CLZV"
// mips:"CLZ"
// ppc64x:"CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-48",-"NEG"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-48" -"NEG"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.LeadingZeros16(n)
}
func LeadingZeros8(n uint8) int {
// amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ"
// amd64/v3: "LZCNTL",- "BSRL"
// amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ"
// amd64/v3: "LZCNTL" - "BSRL"
// arm64:"CLZ"
// arm:"CLZ"
// loong64:"CLZV"
// mips:"CLZ"
// ppc64x:"CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-56",-"NEG"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-56" -"NEG"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.LeadingZeros8(n)
@ -96,8 +96,8 @@ func Len(n uint) int {
// arm:"CLZ"
// loong64:"CLZV"
// mips:"CLZ"
// ppc64x:"SUBC","CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64"
// ppc64x:"SUBC" "CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.Len(n)
@ -110,62 +110,62 @@ func Len64(n uint64) int {
// arm:"CLZ"
// loong64:"CLZV"
// mips:"CLZ"
// ppc64x:"SUBC","CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64"
// ppc64x:"SUBC" "CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.Len64(n)
}
func SubFromLen64(n uint64) int {
// loong64:"CLZV",-"ADD"
// ppc64x:"CNTLZD",-"SUBC"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t",-"ADDI",-"NEG"
// loong64:"CLZV" -"ADD"
// ppc64x:"CNTLZD" -"SUBC"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " -"ADDI" -"NEG"
return 64 - bits.Len64(n)
}
func CompareWithLen64(n uint64) bool {
// loong64:"CLZV",-"ADD",-"[$]64",-"[$]9"
// loong64:"CLZV" -"ADD" -"[$]64" -"[$]9"
return bits.Len64(n) < 9
}
func Len32(n uint32) int {
// amd64/v1,amd64/v2:"BSRQ","LEAQ",-"CMOVQEQ"
// amd64/v1,amd64/v2:"BSRQ" "LEAQ" -"CMOVQEQ"
// amd64/v3: "LZCNTL"
// arm64:"CLZ"
// arm:"CLZ"
// loong64:"CLZW"
// mips:"CLZ"
// ppc64x: "CNTLZW"
// riscv64/rva22u64,riscv64/rva23u64:"CLZW","ADDI\t\\$-32"
// riscv64/rva22u64,riscv64/rva23u64:"CLZW" "ADDI [$]-32"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.Len32(n)
}
func Len16(n uint16) int {
// amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ"
// amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ"
// amd64/v3: "LZCNTL"
// arm64:"CLZ"
// arm:"CLZ"
// loong64:"CLZV"
// mips:"CLZ"
// ppc64x:"SUBC","CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64"
// ppc64x:"SUBC" "CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.Len16(n)
}
func Len8(n uint8) int {
// amd64/v1,amd64/v2:"BSRL","LEAL",-"CMOVQEQ"
// amd64/v1,amd64/v2:"BSRL" "LEAL" -"CMOVQEQ"
// amd64/v3: "LZCNTL"
// arm64:"CLZ"
// arm:"CLZ"
// loong64:"CLZV"
// mips:"CLZ"
// ppc64x:"SUBC","CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ\t","ADDI\t\\$-64"
// ppc64x:"SUBC" "CNTLZD"
// riscv64/rva22u64,riscv64/rva23u64:"CLZ " "ADDI [$]-64"
// s390x:"FLOGR"
// wasm:"I64Clz"
return bits.Len8(n)
@ -179,10 +179,10 @@ func Len8(n uint8) int {
func OnesCount(n uint) int {
// amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT"
// amd64:"POPCNTQ"
// arm64:"VCNT","VUADDLV"
// arm64:"VCNT" "VUADDLV"
// loong64:"VPCNTV"
// ppc64x:"POPCNTD"
// riscv64:"CPOP\t"
// riscv64:"CPOP "
// s390x:"POPCNT"
// wasm:"I64Popcnt"
return bits.OnesCount(n)
@ -191,10 +191,10 @@ func OnesCount(n uint) int {
func OnesCount64(n uint64) int {
// amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT"
// amd64:"POPCNTQ"
// arm64:"VCNT","VUADDLV"
// arm64:"VCNT" "VUADDLV"
// loong64:"VPCNTV"
// ppc64x:"POPCNTD"
// riscv64:"CPOP\t"
// riscv64:"CPOP "
// s390x:"POPCNT"
// wasm:"I64Popcnt"
return bits.OnesCount64(n)
@ -203,7 +203,7 @@ func OnesCount64(n uint64) int {
func OnesCount32(n uint32) int {
// amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT"
// amd64:"POPCNTL"
// arm64:"VCNT","VUADDLV"
// arm64:"VCNT" "VUADDLV"
// loong64:"VPCNTW"
// ppc64x:"POPCNTW"
// riscv64:"CPOPW"
@ -215,10 +215,10 @@ func OnesCount32(n uint32) int {
func OnesCount16(n uint16) int {
// amd64/v2:-".*x86HasPOPCNT" amd64/v3:-".*x86HasPOPCNT"
// amd64:"POPCNTL"
// arm64:"VCNT","VUADDLV"
// arm64:"VCNT" "VUADDLV"
// loong64:"VPCNTH"
// ppc64x:"POPCNTW"
// riscv64:"CPOP\t"
// riscv64:"CPOP "
// s390x:"POPCNT"
// wasm:"I64Popcnt"
return bits.OnesCount16(n)
@ -226,7 +226,7 @@ func OnesCount16(n uint16) int {
func OnesCount8(n uint8) int {
// ppc64x:"POPCNTB"
// riscv64/rva22u64,riscv64/rva23u64:"CPOP\t"
// riscv64/rva22u64,riscv64/rva23u64:"CPOP "
// s390x:"POPCNT"
// wasm:"I64Popcnt"
return bits.OnesCount8(n)
@ -252,7 +252,7 @@ func Reverse32(n uint32) uint32 {
}
func Reverse16(n uint16) uint16 {
// loong64:"BITREV4B","REVB2H"
// loong64:"BITREV4B" "REVB2H"
return bits.Reverse16(n)
}
@ -292,20 +292,20 @@ func ReverseBytes32(n uint32) uint32 {
// arm64:"REVW"
// loong64:"REVB2W"
// ppc64x/power10: "BRW"
// riscv64/rva22u64,riscv64/rva23u64:"REV8","SRLI\t\\$32"
// riscv64/rva22u64,riscv64/rva23u64:"REV8" "SRLI [$]32"
// s390x:"MOVWBR"
return bits.ReverseBytes32(n)
}
func ReverseBytes16(n uint16) uint16 {
// amd64:"ROLW"
// arm/5:"SLL","SRL","ORR"
// arm/5:"SLL" "SRL" "ORR"
// arm/6:"REV16"
// arm/7:"REV16"
// arm64:"REV16W",-"UBFX",-"ORR"
// arm64:"REV16W" -"UBFX" -"ORR"
// loong64:"REVB2H"
// ppc64x/power10: "BRH"
// riscv64/rva22u64,riscv64/rva23u64:"REV8","SRLI\t\\$48"
// riscv64/rva22u64,riscv64/rva23u64:"REV8" "SRLI [$]48"
return bits.ReverseBytes16(n)
}
@ -319,16 +319,16 @@ func RotateLeft64(n uint64) uint64 {
// loong64:"ROTRV"
// ppc64x:"ROTL"
// riscv64:"RORI"
// s390x:"RISBGZ\t[$]0, [$]63, [$]37, "
// s390x:"RISBGZ [$]0, [$]63, [$]37, "
// wasm:"I64Rotl"
return bits.RotateLeft64(n, 37)
}
func RotateLeft32(n uint32) uint32 {
// amd64:"ROLL" 386:"ROLL"
// arm:`MOVW\tR[0-9]+@>23`
// arm:`MOVW R[0-9]+@>23`
// arm64:"RORW"
// loong64:"ROTR\t"
// loong64:"ROTR "
// ppc64x:"ROTLW"
// riscv64:"RORIW"
// s390x:"RLL"
@ -338,15 +338,15 @@ func RotateLeft32(n uint32) uint32 {
func RotateLeft16(n uint16, s int) uint16 {
// amd64:"ROLW" 386:"ROLW"
// arm64:"RORW",-"CSEL"
// loong64:"ROTR\t","SLLV"
// arm64:"RORW" -"CSEL"
// loong64:"ROTR " "SLLV"
return bits.RotateLeft16(n, s)
}
func RotateLeft8(n uint8, s int) uint8 {
// amd64:"ROLB" 386:"ROLB"
// arm64:"LSL","LSR",-"CSEL"
// loong64:"OR","SLLV","SRLV"
// arm64:"LSL" "LSR" -"CSEL"
// loong64:"OR" "SLLV" "SRLV"
return bits.RotateLeft8(n, s)
}
@ -373,10 +373,10 @@ func RotateLeftVariable64(n uint64, m int) uint64 {
}
func RotateLeftVariable32(n uint32, m int) uint32 {
// arm:`MOVW\tR[0-9]+@>R[0-9]+`
// arm:`MOVW R[0-9]+@>R[0-9]+`
// amd64:"ROLL"
// arm64:"RORW"
// loong64:"ROTR\t"
// loong64:"ROTR "
// ppc64x:"ROTLW"
// riscv64:"ROLW"
// s390x:"RLL"
@ -390,78 +390,78 @@ func RotateLeftVariable32(n uint32, m int) uint32 {
func TrailingZeros(n uint) int {
// 386:"BSFL"
// amd64/v1,amd64/v2:"BSFQ","MOVL\t\\$64","CMOVQEQ"
// amd64/v1,amd64/v2:"BSFQ" "MOVL [$]64" "CMOVQEQ"
// amd64/v3:"TZCNTQ"
// arm:"CLZ"
// arm64:"RBIT","CLZ"
// arm64:"RBIT" "CLZ"
// loong64:"CTZV"
// ppc64x/power8:"ANDN","POPCNTD"
// ppc64x/power8:"ANDN" "POPCNTD"
// ppc64x/power9: "CNTTZD"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ "
// s390x:"FLOGR"
// wasm:"I64Ctz"
return bits.TrailingZeros(n)
}
func TrailingZeros64(n uint64) int {
// 386:"BSFL","JNE"
// amd64/v1,amd64/v2:"BSFQ","MOVL\t\\$64","CMOVQEQ"
// 386:"BSFL" "JNE"
// amd64/v1,amd64/v2:"BSFQ" "MOVL [$]64" "CMOVQEQ"
// amd64/v3:"TZCNTQ"
// arm64:"RBIT","CLZ"
// arm64:"RBIT" "CLZ"
// loong64:"CTZV"
// ppc64x/power8:"ANDN","POPCNTD"
// ppc64x/power8:"ANDN" "POPCNTD"
// ppc64x/power9: "CNTTZD"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ "
// s390x:"FLOGR"
// wasm:"I64Ctz"
return bits.TrailingZeros64(n)
}
func TrailingZeros64Subtract(n uint64) int {
// ppc64x/power8:"NEG","SUBC","ANDN","POPCNTD"
// ppc64x/power9:"SUBC","CNTTZD"
// ppc64x/power8:"NEG" "SUBC" "ANDN" "POPCNTD"
// ppc64x/power9:"SUBC" "CNTTZD"
return bits.TrailingZeros64(1 - n)
}
func TrailingZeros32(n uint32) int {
// 386:"BSFL"
// amd64/v1,amd64/v2:"BTSQ\\t\\$32","BSFQ"
// amd64/v1,amd64/v2:"BTSQ [$]32" "BSFQ"
// amd64/v3:"TZCNTL"
// arm:"CLZ"
// arm64:"RBITW","CLZW"
// arm64:"RBITW" "CLZW"
// loong64:"CTZW"
// ppc64x/power8:"ANDN","POPCNTW"
// ppc64x/power8:"ANDN" "POPCNTW"
// ppc64x/power9: "CNTTZW"
// riscv64/rva22u64,riscv64/rva23u64: "CTZW"
// s390x:"FLOGR","MOVWZ"
// s390x:"FLOGR" "MOVWZ"
// wasm:"I64Ctz"
return bits.TrailingZeros32(n)
}
func TrailingZeros16(n uint16) int {
// 386:"BSFL\t"
// amd64:"BSFL","ORL\\t\\$65536"
// arm:"ORR\t\\$65536","CLZ",-"MOVHU\tR"
// arm64:"ORR\t\\$65536","RBITW","CLZW",-"MOVHU\tR",-"RBIT\t",-"CLZ\t"
// 386:"BSFL "
// amd64:"BSFL" "ORL [$]65536"
// arm:"ORR [$]65536" "CLZ" -"MOVHU R"
// arm64:"ORR [$]65536" "RBITW" "CLZW" -"MOVHU R" -"RBIT " -"CLZ "
// loong64:"CTZV"
// ppc64x/power8:"POPCNTW","ADD\t\\$-1"
// ppc64x/power9:"CNTTZD","ORIS\\t\\$1"
// riscv64/rva22u64,riscv64/rva23u64: "ORI\t\\$65536","CTZW"
// s390x:"FLOGR","OR\t\\$65536"
// ppc64x/power8:"POPCNTW" "ADD [$]-1"
// ppc64x/power9:"CNTTZD" "ORIS [$]1"
// riscv64/rva22u64,riscv64/rva23u64: "ORI [$]65536" "CTZW"
// s390x:"FLOGR" "OR [$]65536"
// wasm:"I64Ctz"
return bits.TrailingZeros16(n)
}
func TrailingZeros8(n uint8) int {
// 386:"BSFL"
// amd64:"BSFL","ORL\\t\\$256"
// arm:"ORR\t\\$256","CLZ",-"MOVBU\tR"
// arm64:"ORR\t\\$256","RBITW","CLZW",-"MOVBU\tR",-"RBIT\t",-"CLZ\t"
// amd64:"BSFL" "ORL [$]256"
// arm:"ORR [$]256" "CLZ" -"MOVBU R"
// arm64:"ORR [$]256" "RBITW" "CLZW" -"MOVBU R" -"RBIT " -"CLZ "
// loong64:"CTZV"
// ppc64x/power8:"POPCNTB","ADD\t\\$-1"
// ppc64x/power9:"CNTTZD","OR\t\\$256"
// riscv64/rva22u64,riscv64/rva23u64: "ORI\t\\$256","CTZW"
// s390x:"FLOGR","OR\t\\$256"
// ppc64x/power8:"POPCNTB" "ADD [$]-1"
// ppc64x/power9:"CNTTZD" "OR [$]256"
// riscv64/rva22u64,riscv64/rva23u64: "ORI [$]256" "CTZW"
// s390x:"FLOGR" "OR [$]256"
// wasm:"I64Ctz"
return bits.TrailingZeros8(n)
}
@ -471,7 +471,7 @@ func TrailingZeros8(n uint8) int {
func IterateBits(n uint) int {
i := 0
for n != 0 {
// amd64/v1,amd64/v2:"BSFQ",-"CMOVEQ"
// amd64/v1,amd64/v2:"BSFQ" -"CMOVEQ"
// amd64/v3:"TZCNTQ"
i += bits.TrailingZeros(n)
n &= n - 1
@ -482,9 +482,9 @@ func IterateBits(n uint) int {
func IterateBits64(n uint64) int {
i := 0
for n != 0 {
// amd64/v1,amd64/v2:"BSFQ",-"CMOVEQ"
// amd64/v1,amd64/v2:"BSFQ" -"CMOVEQ"
// amd64/v3:"TZCNTQ"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ "
i += bits.TrailingZeros64(n)
n &= n - 1
}
@ -494,9 +494,9 @@ func IterateBits64(n uint64) int {
func IterateBits32(n uint32) int {
i := 0
for n != 0 {
// amd64/v1,amd64/v2:"BSFL",-"BTSQ"
// amd64/v1,amd64/v2:"BSFL" -"BTSQ"
// amd64/v3:"TZCNTL"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ "
i += bits.TrailingZeros32(n)
n &= n - 1
}
@ -506,10 +506,10 @@ func IterateBits32(n uint32) int {
func IterateBits16(n uint16) int {
i := 0
for n != 0 {
// amd64/v1,amd64/v2:"BSFL",-"BTSL"
// amd64/v1,amd64/v2:"BSFL" -"BTSL"
// amd64/v3:"TZCNTL"
// arm64:"RBITW","CLZW",-"ORR"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t",-"ORR"
// arm64:"RBITW" "CLZW" -"ORR"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ " -"ORR"
i += bits.TrailingZeros16(n)
n &= n - 1
}
@ -519,10 +519,10 @@ func IterateBits16(n uint16) int {
func IterateBits8(n uint8) int {
i := 0
for n != 0 {
// amd64/v1,amd64/v2:"BSFL",-"BTSL"
// amd64/v1,amd64/v2:"BSFL" -"BTSL"
// amd64/v3:"TZCNTL"
// arm64:"RBITW","CLZW",-"ORR"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ\t",-"ORR"
// arm64:"RBITW" "CLZW" -"ORR"
// riscv64/rva22u64,riscv64/rva23u64: "CTZ " -"ORR"
i += bits.TrailingZeros8(n)
n &= n - 1
}
@ -534,44 +534,44 @@ func IterateBits8(n uint8) int {
// --------------- //
func Add(x, y, ci uint) (r, co uint) {
// arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP"
// amd64:"NEGL","ADCQ","SBBQ","NEGQ"
// arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP"
// amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ"
// ppc64x: "ADDC", "ADDE", "ADDZE"
// s390x:"ADDE","ADDC\t[$]-1,"
// riscv64: "ADD","SLTU"
// s390x:"ADDE" "ADDC [$]-1,"
// riscv64: "ADD" "SLTU"
return bits.Add(x, y, ci)
}
func AddC(x, ci uint) (r, co uint) {
// arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP"
// amd64:"NEGL","ADCQ","SBBQ","NEGQ"
// arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP"
// amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ"
// loong64: "ADDV", "SGTU"
// ppc64x: "ADDC", "ADDE", "ADDZE"
// s390x:"ADDE","ADDC\t[$]-1,"
// mips64:"ADDV","SGTU"
// riscv64: "ADD","SLTU"
// s390x:"ADDE" "ADDC [$]-1,"
// mips64:"ADDV" "SGTU"
// riscv64: "ADD" "SLTU"
return bits.Add(x, 7, ci)
}
func AddZ(x, y uint) (r, co uint) {
// arm64:"ADDS","ADC",-"ADCS",-"ADD\t",-"CMP"
// amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
// arm64:"ADDS" "ADC" -"ADCS" -"ADD " -"CMP"
// amd64:"ADDQ" "SBBQ" "NEGQ" -"NEGL" -"ADCQ"
// loong64: "ADDV", "SGTU"
// ppc64x: "ADDC", -"ADDE", "ADDZE"
// s390x:"ADDC",-"ADDC\t[$]-1,"
// mips64:"ADDV","SGTU"
// riscv64: "ADD","SLTU"
// s390x:"ADDC" -"ADDC [$]-1,"
// mips64:"ADDV" "SGTU"
// riscv64: "ADD" "SLTU"
return bits.Add(x, y, 0)
}
func AddR(x, y, ci uint) uint {
// arm64:"ADDS","ADCS",-"ADD\t",-"CMP"
// amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
// arm64:"ADDS" "ADCS" -"ADD " -"CMP"
// amd64:"NEGL" "ADCQ" -"SBBQ" -"NEGQ"
// loong64: "ADDV", -"SGTU"
// ppc64x: "ADDC", "ADDE", -"ADDZE"
// s390x:"ADDE","ADDC\t[$]-1,"
// mips64:"ADDV",-"SGTU"
// riscv64: "ADD",-"SLTU"
// s390x:"ADDE" "ADDC [$]-1,"
// mips64:"ADDV" -"SGTU"
// riscv64: "ADD" -"SLTU"
r, _ := bits.Add(x, y, ci)
return r
}
@ -579,54 +579,54 @@ func AddR(x, y, ci uint) uint {
func AddM(p, q, r *[3]uint) {
var c uint
r[0], c = bits.Add(p[0], q[0], c)
// arm64:"ADCS",-"ADD\t",-"CMP"
// amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
// s390x:"ADDE",-"ADDC\t[$]-1,"
// arm64:"ADCS" -"ADD " -"CMP"
// amd64:"ADCQ" -"NEGL" -"SBBQ" -"NEGQ"
// s390x:"ADDE" -"ADDC [$]-1,"
r[1], c = bits.Add(p[1], q[1], c)
r[2], c = bits.Add(p[2], q[2], c)
}
func Add64(x, y, ci uint64) (r, co uint64) {
// arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP"
// amd64:"NEGL","ADCQ","SBBQ","NEGQ"
// arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP"
// amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ"
// loong64: "ADDV", "SGTU"
// ppc64x: "ADDC", "ADDE", "ADDZE"
// s390x:"ADDE","ADDC\t[$]-1,"
// mips64:"ADDV","SGTU"
// riscv64: "ADD","SLTU"
// s390x:"ADDE" "ADDC [$]-1,"
// mips64:"ADDV" "SGTU"
// riscv64: "ADD" "SLTU"
return bits.Add64(x, y, ci)
}
func Add64C(x, ci uint64) (r, co uint64) {
// arm64:"ADDS","ADCS","ADC",-"ADD\t",-"CMP"
// amd64:"NEGL","ADCQ","SBBQ","NEGQ"
// arm64:"ADDS" "ADCS" "ADC" -"ADD " -"CMP"
// amd64:"NEGL" "ADCQ" "SBBQ" "NEGQ"
// loong64: "ADDV", "SGTU"
// ppc64x: "ADDC", "ADDE", "ADDZE"
// s390x:"ADDE","ADDC\t[$]-1,"
// mips64:"ADDV","SGTU"
// riscv64: "ADD","SLTU"
// s390x:"ADDE" "ADDC [$]-1,"
// mips64:"ADDV" "SGTU"
// riscv64: "ADD" "SLTU"
return bits.Add64(x, 7, ci)
}
func Add64Z(x, y uint64) (r, co uint64) {
// arm64:"ADDS","ADC",-"ADCS",-"ADD\t",-"CMP"
// amd64:"ADDQ","SBBQ","NEGQ",-"NEGL",-"ADCQ"
// arm64:"ADDS" "ADC" -"ADCS" -"ADD " -"CMP"
// amd64:"ADDQ" "SBBQ" "NEGQ" -"NEGL" -"ADCQ"
// loong64: "ADDV", "SGTU"
// ppc64x: "ADDC", -"ADDE", "ADDZE"
// s390x:"ADDC",-"ADDC\t[$]-1,"
// mips64:"ADDV","SGTU"
// riscv64: "ADD","SLTU"
// s390x:"ADDC" -"ADDC [$]-1,"
// mips64:"ADDV" "SGTU"
// riscv64: "ADD" "SLTU"
return bits.Add64(x, y, 0)
}
func Add64R(x, y, ci uint64) uint64 {
// arm64:"ADDS","ADCS",-"ADD\t",-"CMP"
// amd64:"NEGL","ADCQ",-"SBBQ",-"NEGQ"
// arm64:"ADDS" "ADCS" -"ADD " -"CMP"
// amd64:"NEGL" "ADCQ" -"SBBQ" -"NEGQ"
// loong64: "ADDV", -"SGTU"
// ppc64x: "ADDC", "ADDE", -"ADDZE"
// s390x:"ADDE","ADDC\t[$]-1,"
// mips64:"ADDV",-"SGTU"
// riscv64: "ADD",-"SLTU"
// s390x:"ADDE" "ADDC [$]-1,"
// mips64:"ADDV" -"SGTU"
// riscv64: "ADD" -"SLTU"
r, _ := bits.Add64(x, y, ci)
return r
}
@ -634,10 +634,10 @@ func Add64R(x, y, ci uint64) uint64 {
func Add64M(p, q, r *[3]uint64) {
var c uint64
r[0], c = bits.Add64(p[0], q[0], c)
// arm64:"ADCS",-"ADD\t",-"CMP"
// amd64:"ADCQ",-"NEGL",-"SBBQ",-"NEGQ"
// arm64:"ADCS" -"ADD " -"CMP"
// amd64:"ADCQ" -"NEGL" -"SBBQ" -"NEGQ"
// ppc64x: -"ADDC", "ADDE", -"ADDZE"
// s390x:"ADDE",-"ADDC\t[$]-1,"
// s390x:"ADDE" -"ADDC [$]-1,"
r[1], c = bits.Add64(p[1], q[1], c)
r[2], c = bits.Add64(p[2], q[2], c)
}
@ -645,22 +645,22 @@ func Add64M(p, q, r *[3]uint64) {
func Add64M0(p, q, r *[3]uint64) {
var c uint64
r[0], c = bits.Add64(p[0], q[0], 0)
// ppc64x: -"ADDC", -"ADDE", "ADDZE\tR[1-9]"
// ppc64x: -"ADDC", -"ADDE", "ADDZE R[1-9]"
r[1], c = bits.Add64(p[1], 0, c)
// ppc64x: -"ADDC", "ADDE", -"ADDZE"
r[2], c = bits.Add64(p[2], p[2], c)
}
func Add64MSaveC(p, q, r, c *[2]uint64) {
// ppc64x: "ADDC\tR", "ADDZE"
// ppc64x: "ADDC R", "ADDZE"
r[0], c[0] = bits.Add64(p[0], q[0], 0)
// ppc64x: "ADDC\t[$]-1", "ADDE", "ADDZE"
// ppc64x: "ADDC [$]-1", "ADDE", "ADDZE"
r[1], c[1] = bits.Add64(p[1], q[1], c[0])
}
func Add64PanicOnOverflowEQ(a, b uint64) uint64 {
r, c := bits.Add64(a, b, 0)
// s390x:"BRC\t[$]3,",-"ADDE"
// s390x:"BRC [$]3," -"ADDE"
if c == 1 {
panic("overflow")
}
@ -669,7 +669,7 @@ func Add64PanicOnOverflowEQ(a, b uint64) uint64 {
func Add64PanicOnOverflowNE(a, b uint64) uint64 {
r, c := bits.Add64(a, b, 0)
// s390x:"BRC\t[$]3,",-"ADDE"
// s390x:"BRC [$]3," -"ADDE"
if c != 0 {
panic("overflow")
}
@ -678,7 +678,7 @@ func Add64PanicOnOverflowNE(a, b uint64) uint64 {
func Add64PanicOnOverflowGT(a, b uint64) uint64 {
r, c := bits.Add64(a, b, 0)
// s390x:"BRC\t[$]3,",-"ADDE"
// s390x:"BRC [$]3," -"ADDE"
if c > 0 {
panic("overflow")
}
@ -690,7 +690,7 @@ func Add64MPanicOnOverflowEQ(a, b [2]uint64) [2]uint64 {
var c uint64
r[0], c = bits.Add64(a[0], b[0], c)
r[1], c = bits.Add64(a[1], b[1], c)
// s390x:"BRC\t[$]3,"
// s390x:"BRC [$]3,"
if c == 1 {
panic("overflow")
}
@ -702,7 +702,7 @@ func Add64MPanicOnOverflowNE(a, b [2]uint64) [2]uint64 {
var c uint64
r[0], c = bits.Add64(a[0], b[0], c)
r[1], c = bits.Add64(a[1], b[1], c)
// s390x:"BRC\t[$]3,"
// s390x:"BRC [$]3,"
if c != 0 {
panic("overflow")
}
@ -714,7 +714,7 @@ func Add64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 {
var c uint64
r[0], c = bits.Add64(a[0], b[0], c)
r[1], c = bits.Add64(a[1], b[1], c)
// s390x:"BRC\t[$]3,"
// s390x:"BRC [$]3,"
if c > 0 {
panic("overflow")
}
@ -731,23 +731,24 @@ func Add64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 {
//
// This is what happened on PPC64 when compiling
// crypto/internal/edwards25519/field.feMulGeneric.
func Add64MultipleChains(a, b, c, d [2]uint64) {
func Add64MultipleChains(a, b, c, d [2]uint64) [2]uint64 {
var cx, d1, d2 uint64
a1, a2 := a[0], a[1]
b1, b2 := b[0], b[1]
c1, c2 := c[0], c[1]
// ppc64x: "ADDC\tR\\d+,", -"ADDE", -"MOVD\tXER"
// ppc64x: "ADDC R\\d+,", -"ADDE", -"MOVD XER"
d1, cx = bits.Add64(a1, b1, 0)
// ppc64x: "ADDE", -"ADDC", -"MOVD\t.*, XER"
// ppc64x: "ADDE", -"ADDC", -"MOVD .*, XER"
d2, _ = bits.Add64(a2, b2, cx)
// ppc64x: "ADDC\tR\\d+,", -"ADDE", -"MOVD\tXER"
// ppc64x: "ADDC R\\d+,", -"ADDE", -"MOVD XER"
d1, cx = bits.Add64(c1, d1, 0)
// ppc64x: "ADDE", -"ADDC", -"MOVD\t.*, XER"
// ppc64x: "ADDE", -"ADDC", -"MOVD .*, XER"
d2, _ = bits.Add64(c2, d2, cx)
d[0] = d1
d[1] = d2
return d
}
// --------------- //
@ -755,53 +756,53 @@ func Add64MultipleChains(a, b, c, d [2]uint64) {
// --------------- //
func Sub(x, y, ci uint) (r, co uint) {
// amd64:"NEGL","SBBQ","NEGQ"
// arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP"
// loong64:"SUBV","SGTU"
// amd64:"NEGL" "SBBQ" "NEGQ"
// arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP"
// loong64:"SUBV" "SGTU"
// ppc64x:"SUBC", "SUBE", "SUBZE", "NEG"
// s390x:"SUBE"
// mips64:"SUBV","SGTU"
// riscv64: "SUB","SLTU"
// mips64:"SUBV" "SGTU"
// riscv64: "SUB" "SLTU"
return bits.Sub(x, y, ci)
}
func SubC(x, ci uint) (r, co uint) {
// amd64:"NEGL","SBBQ","NEGQ"
// arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP"
// loong64:"SUBV","SGTU"
// amd64:"NEGL" "SBBQ" "NEGQ"
// arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP"
// loong64:"SUBV" "SGTU"
// ppc64x:"SUBC", "SUBE", "SUBZE", "NEG"
// s390x:"SUBE"
// mips64:"SUBV","SGTU"
// riscv64: "SUB","SLTU"
// mips64:"SUBV" "SGTU"
// riscv64: "SUB" "SLTU"
return bits.Sub(x, 7, ci)
}
func SubZ(x, y uint) (r, co uint) {
// amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
// arm64:"SUBS","NGC","NEG",-"SBCS",-"ADD",-"SUB\t",-"CMP"
// loong64:"SUBV","SGTU"
// amd64:"SUBQ" "SBBQ" "NEGQ" -"NEGL"
// arm64:"SUBS" "NGC" "NEG" -"SBCS" -"ADD" -"SUB " -"CMP"
// loong64:"SUBV" "SGTU"
// ppc64x:"SUBC", -"SUBE", "SUBZE", "NEG"
// s390x:"SUBC"
// mips64:"SUBV","SGTU"
// riscv64: "SUB","SLTU"
// mips64:"SUBV" "SGTU"
// riscv64: "SUB" "SLTU"
return bits.Sub(x, y, 0)
}
func SubR(x, y, ci uint) uint {
// amd64:"NEGL","SBBQ",-"NEGQ"
// arm64:"NEGS","SBCS",-"NGC",-"NEG\t",-"ADD",-"SUB",-"CMP"
// loong64:"SUBV",-"SGTU"
// amd64:"NEGL" "SBBQ" -"NEGQ"
// arm64:"NEGS" "SBCS" -"NGC" -"NEG " -"ADD" -"SUB" -"CMP"
// loong64:"SUBV" -"SGTU"
// ppc64x:"SUBC", "SUBE", -"SUBZE", -"NEG"
// s390x:"SUBE"
// riscv64: "SUB",-"SLTU"
// riscv64: "SUB" -"SLTU"
r, _ := bits.Sub(x, y, ci)
return r
}
func SubM(p, q, r *[3]uint) {
var c uint
r[0], c = bits.Sub(p[0], q[0], c)
// amd64:"SBBQ",-"NEGL",-"NEGQ"
// arm64:"SBCS",-"NEGS",-"NGC",-"NEG",-"ADD",-"SUB",-"CMP"
// amd64:"SBBQ" -"NEGL" -"NEGQ"
// arm64:"SBCS" -"NEGS" -"NGC" -"NEG" -"ADD" -"SUB" -"CMP"
// ppc64x:-"SUBC", "SUBE", -"SUBZE", -"NEG"
// s390x:"SUBE"
r[1], c = bits.Sub(p[1], q[1], c)
@ -809,68 +810,68 @@ func SubM(p, q, r *[3]uint) {
}
func Sub64(x, y, ci uint64) (r, co uint64) {
// amd64:"NEGL","SBBQ","NEGQ"
// arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP"
// loong64:"SUBV","SGTU"
// amd64:"NEGL" "SBBQ" "NEGQ"
// arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP"
// loong64:"SUBV" "SGTU"
// ppc64x:"SUBC", "SUBE", "SUBZE", "NEG"
// s390x:"SUBE"
// mips64:"SUBV","SGTU"
// riscv64: "SUB","SLTU"
// mips64:"SUBV" "SGTU"
// riscv64: "SUB" "SLTU"
return bits.Sub64(x, y, ci)
}
func Sub64C(x, ci uint64) (r, co uint64) {
// amd64:"NEGL","SBBQ","NEGQ"
// arm64:"NEGS","SBCS","NGC","NEG",-"ADD",-"SUB",-"CMP"
// loong64:"SUBV","SGTU"
// amd64:"NEGL" "SBBQ" "NEGQ"
// arm64:"NEGS" "SBCS" "NGC" "NEG" -"ADD" -"SUB" -"CMP"
// loong64:"SUBV" "SGTU"
// ppc64x:"SUBC", "SUBE", "SUBZE", "NEG"
// s390x:"SUBE"
// mips64:"SUBV","SGTU"
// riscv64: "SUB","SLTU"
// mips64:"SUBV" "SGTU"
// riscv64: "SUB" "SLTU"
return bits.Sub64(x, 7, ci)
}
func Sub64Z(x, y uint64) (r, co uint64) {
// amd64:"SUBQ","SBBQ","NEGQ",-"NEGL"
// arm64:"SUBS","NGC","NEG",-"SBCS",-"ADD",-"SUB\t",-"CMP"
// loong64:"SUBV","SGTU"
// amd64:"SUBQ" "SBBQ" "NEGQ" -"NEGL"
// arm64:"SUBS" "NGC" "NEG" -"SBCS" -"ADD" -"SUB " -"CMP"
// loong64:"SUBV" "SGTU"
// ppc64x:"SUBC", -"SUBE", "SUBZE", "NEG"
// s390x:"SUBC"
// mips64:"SUBV","SGTU"
// riscv64: "SUB","SLTU"
// mips64:"SUBV" "SGTU"
// riscv64: "SUB" "SLTU"
return bits.Sub64(x, y, 0)
}
func Sub64R(x, y, ci uint64) uint64 {
// amd64:"NEGL","SBBQ",-"NEGQ"
// arm64:"NEGS","SBCS",-"NGC",-"NEG\t",-"ADD",-"SUB",-"CMP"
// loong64:"SUBV",-"SGTU"
// amd64:"NEGL" "SBBQ" -"NEGQ"
// arm64:"NEGS" "SBCS" -"NGC" -"NEG " -"ADD" -"SUB" -"CMP"
// loong64:"SUBV" -"SGTU"
// ppc64x:"SUBC", "SUBE", -"SUBZE", -"NEG"
// s390x:"SUBE"
// riscv64: "SUB",-"SLTU"
// riscv64: "SUB" -"SLTU"
r, _ := bits.Sub64(x, y, ci)
return r
}
func Sub64M(p, q, r *[3]uint64) {
var c uint64
r[0], c = bits.Sub64(p[0], q[0], c)
// amd64:"SBBQ",-"NEGL",-"NEGQ"
// arm64:"SBCS",-"NEGS",-"NGC",-"NEG",-"ADD",-"SUB",-"CMP"
// amd64:"SBBQ" -"NEGL" -"NEGQ"
// arm64:"SBCS" -"NEGS" -"NGC" -"NEG" -"ADD" -"SUB" -"CMP"
// s390x:"SUBE"
r[1], c = bits.Sub64(p[1], q[1], c)
r[2], c = bits.Sub64(p[2], q[2], c)
}
func Sub64MSaveC(p, q, r, c *[2]uint64) {
// ppc64x:"SUBC\tR\\d+, R\\d+,", "SUBZE", "NEG"
// ppc64x:"SUBC R\\d+, R\\d+,", "SUBZE", "NEG"
r[0], c[0] = bits.Sub64(p[0], q[0], 0)
// ppc64x:"SUBC\tR\\d+, [$]0,", "SUBE", "SUBZE", "NEG"
// ppc64x:"SUBC R\\d+, [$]0,", "SUBE", "SUBZE", "NEG"
r[1], c[1] = bits.Sub64(p[1], q[1], c[0])
}
func Sub64PanicOnOverflowEQ(a, b uint64) uint64 {
r, b := bits.Sub64(a, b, 0)
// s390x:"BRC\t[$]12,",-"ADDE",-"SUBE"
// s390x:"BRC [$]12," -"ADDE" -"SUBE"
if b == 1 {
panic("overflow")
}
@ -879,7 +880,7 @@ func Sub64PanicOnOverflowEQ(a, b uint64) uint64 {
func Sub64PanicOnOverflowNE(a, b uint64) uint64 {
r, b := bits.Sub64(a, b, 0)
// s390x:"BRC\t[$]12,",-"ADDE",-"SUBE"
// s390x:"BRC [$]12," -"ADDE" -"SUBE"
if b != 0 {
panic("overflow")
}
@ -888,7 +889,7 @@ func Sub64PanicOnOverflowNE(a, b uint64) uint64 {
func Sub64PanicOnOverflowGT(a, b uint64) uint64 {
r, b := bits.Sub64(a, b, 0)
// s390x:"BRC\t[$]12,",-"ADDE",-"SUBE"
// s390x:"BRC [$]12," -"ADDE" -"SUBE"
if b > 0 {
panic("overflow")
}
@ -900,7 +901,7 @@ func Sub64MPanicOnOverflowEQ(a, b [2]uint64) [2]uint64 {
var c uint64
r[0], c = bits.Sub64(a[0], b[0], c)
r[1], c = bits.Sub64(a[1], b[1], c)
// s390x:"BRC\t[$]12,"
// s390x:"BRC [$]12,"
if c == 1 {
panic("overflow")
}
@ -912,7 +913,7 @@ func Sub64MPanicOnOverflowNE(a, b [2]uint64) [2]uint64 {
var c uint64
r[0], c = bits.Sub64(a[0], b[0], c)
r[1], c = bits.Sub64(a[1], b[1], c)
// s390x:"BRC\t[$]12,"
// s390x:"BRC [$]12,"
if c != 0 {
panic("overflow")
}
@ -924,7 +925,7 @@ func Sub64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 {
var c uint64
r[0], c = bits.Sub64(a[0], b[0], c)
r[1], c = bits.Sub64(a[1], b[1], c)
// s390x:"BRC\t[$]12,"
// s390x:"BRC [$]12,"
if c > 0 {
panic("overflow")
}
@ -937,51 +938,51 @@ func Sub64MPanicOnOverflowGT(a, b [2]uint64) [2]uint64 {
func Mul(x, y uint) (hi, lo uint) {
// amd64:"MULQ"
// arm64:"UMULH","MUL"
// loong64:"MULV","MULHVU"
// ppc64x:"MULHDU","MULLD"
// arm64:"UMULH" "MUL"
// loong64:"MULV" "MULHVU"
// ppc64x:"MULHDU" "MULLD"
// s390x:"MLGR"
// mips64: "MULVU"
// riscv64:"MULHU","MUL"
// riscv64:"MULHU" "MUL"
return bits.Mul(x, y)
}
func Mul64(x, y uint64) (hi, lo uint64) {
// amd64:"MULQ"
// arm64:"UMULH","MUL"
// loong64:"MULV","MULHVU"
// ppc64x:"MULHDU","MULLD"
// arm64:"UMULH" "MUL"
// loong64:"MULV" "MULHVU"
// ppc64x:"MULHDU" "MULLD"
// s390x:"MLGR"
// mips64: "MULVU"
// riscv64:"MULHU","MUL"
// riscv64:"MULHU" "MUL"
return bits.Mul64(x, y)
}
func Mul64HiOnly(x, y uint64) uint64 {
// arm64:"UMULH",-"MUL"
// loong64:"MULHVU",-"MULV"
// riscv64:"MULHU",-"MUL\t"
// arm64:"UMULH" -"MUL"
// loong64:"MULHVU" -"MULV"
// riscv64:"MULHU" -"MUL "
hi, _ := bits.Mul64(x, y)
return hi
}
func Mul64LoOnly(x, y uint64) uint64 {
// arm64:"MUL",-"UMULH"
// loong64:"MULV",-"MULHVU"
// riscv64:"MUL\t",-"MULHU"
// arm64:"MUL" -"UMULH"
// loong64:"MULV" -"MULHVU"
// riscv64:"MUL " -"MULHU"
_, lo := bits.Mul64(x, y)
return lo
}
func Mul64Const() (uint64, uint64) {
// 7133701809754865664 == 99<<56
// arm64:"MOVD\t[$]7133701809754865664, R1", "MOVD\t[$]88, R0"
// loong64:"MOVV\t[$]88, R4","MOVV\t[$]7133701809754865664, R5",-"MUL"
// arm64:"MOVD [$]7133701809754865664, R1", "MOVD [$]88, R0"
// loong64:"MOVV [$]88, R4" "MOVV [$]7133701809754865664, R5" -"MUL"
return bits.Mul64(99+88<<8, 1<<56)
}
func MulUintOverflow(p *uint64) []uint64 {
// arm64:"CMP\t[$]72"
// arm64:"CMP [$]72"
return unsafe.Slice(p, 9)
}
@ -995,7 +996,7 @@ func Div(hi, lo, x uint) (q, r uint) {
}
func Div32(hi, lo, x uint32) (q, r uint32) {
// arm64:"ORR","UDIV","MSUB",-"UREM"
// arm64:"ORR" "UDIV" "MSUB" -"UREM"
return bits.Div32(hi, lo, x)
}

218
test/codegen/memcombine.go
View file

@ -16,7 +16,7 @@ import (
// ------------- //
func load_le64(b []byte) uint64 {
// amd64:`MOVQ\s\(.*\),`,-`MOV[BWL]\t[^$]`,-`OR`
// amd64:`MOVQ\s\(.*\),`,-`MOV[BWL] [^$]`,-`OR`
// s390x:`MOVDBR\s\(.*\),`
// arm64:`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`
// loong64:`MOVV\s\(R[0-9]+\),`
@ -26,7 +26,7 @@ func load_le64(b []byte) uint64 {
}
func load_le64_idx(b []byte, idx int) uint64 {
// amd64:`MOVQ\s\(.*\)\(.*\*1\),`,-`MOV[BWL]\t[^$]`,-`OR`
// amd64:`MOVQ\s\(.*\)\(.*\*1\),`,-`MOV[BWL] [^$]`,-`OR`
// s390x:`MOVDBR\s\(.*\)\(.*\*1\),`
// arm64:`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[BHW]`
// loong64:`MOVV\s\(R[0-9]+\)\(R[0-9]+\),`
@ -78,7 +78,7 @@ func load_le16_idx(b []byte, idx int) uint16 {
}
func load_be64(b []byte) uint64 {
// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR`
// amd64/v3:`MOVBEQ`
// s390x:`MOVD\s\(.*\),`
// arm64:`REV`,`MOVD\s\(R[0-9]+\),`,-`MOV[BHW]`,-`REVW`,-`REV16W`
@ -88,8 +88,8 @@ func load_be64(b []byte) uint64 {
}
func load_be64_idx(b []byte, idx int) uint64 {
// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
// amd64/v3: `MOVBEQ\t\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
// amd64/v1,amd64/v2:`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR`
// amd64/v3: `MOVBEQ \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
// s390x:`MOVD\s\(.*\)\(.*\*1\),`
// arm64:`REV`,`MOVD\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[WHB]`,-`REVW`,-`REV16W`
// ppc64le:`MOVDBR`,-`MOV[BHW]Z`
@ -109,7 +109,7 @@ func load_be32(b []byte) uint32 {
func load_be32_idx(b []byte, idx int) uint32 {
// amd64/v1,amd64/v2:`BSWAPL`,-`MOV[BW]`,-`OR`
// amd64/v3: `MOVBEL\t\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
// amd64/v3: `MOVBEL \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
// s390x:`MOVWZ\s\(.*\)\(.*\*1\),`
// arm64:`REVW`,`MOVWU\s\(R[0-9]+\)\(R[0-9]+\),`,-`MOV[HB]`,-`REV16W`
// ppc64le:`MOVWBR`,-`MOV[BH]Z`
@ -136,79 +136,79 @@ func load_be16_idx(b []byte, idx int) uint16 {
}
func load_le_byte2_uint16(s []byte) uint16 {
// arm64:`MOVHU\t\(R[0-9]+\)`,-`ORR`,-`MOVB`
// arm64:`MOVHU \(R[0-9]+\)`,-`ORR`,-`MOVB`
// 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
// amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
// ppc64le:`MOVHZ\t\(R[0-9]+\)`,-`MOVBZ`
// ppc64le:`MOVHZ \(R[0-9]+\)`,-`MOVBZ`
// ppc64:`MOVHBR`,-`MOVBZ`
return uint16(s[0]) | uint16(s[1])<<8
}
func load_le_byte2_uint16_inv(s []byte) uint16 {
// arm64:`MOVHU\t\(R[0-9]+\)`,-`ORR`,-`MOVB`
// arm64:`MOVHU \(R[0-9]+\)`,-`ORR`,-`MOVB`
// 386:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
// amd64:`MOVWLZX\s\([A-Z]+\)`,-`MOVB`,-`OR`
// ppc64le:`MOVHZ\t\(R[0-9]+\)`,-`MOVBZ`
// ppc64le:`MOVHZ \(R[0-9]+\)`,-`MOVBZ`
// ppc64:`MOVHBR`,-`MOVBZ`
return uint16(s[1])<<8 | uint16(s[0])
}
func load_le_byte4_uint32(s []byte) uint32 {
// arm64:`MOVWU\t\(R[0-9]+\)`,-`ORR`,-`MOV[BH]`
// arm64:`MOVWU \(R[0-9]+\)`,-`ORR`,-`MOV[BH]`
// 386:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR`
// amd64:`MOVL\s\([A-Z]+\)`,-`MOV[BW]`,-`OR`
// ppc64le:`MOVWZ\t\(R[0-9]+\)`,-`MOV[BH]Z`
// ppc64le:`MOVWZ \(R[0-9]+\)`,-`MOV[BH]Z`
// ppc64:`MOVWBR`,-MOV[BH]Z`
return uint32(s[0]) | uint32(s[1])<<8 | uint32(s[2])<<16 | uint32(s[3])<<24
}
func load_le_byte4_uint32_inv(s []byte) uint32 {
// arm64:`MOVWU\t\(R[0-9]+\)`,-`ORR`,-`MOV[BH]`
// arm64:`MOVWU \(R[0-9]+\)`,-`ORR`,-`MOV[BH]`
// ppc64le:`MOVWZ`,-`MOV[BH]Z`
// ppc64:`MOVWBR`,-`MOV[BH]Z`
return uint32(s[3])<<24 | uint32(s[2])<<16 | uint32(s[1])<<8 | uint32(s[0])
}
func load_le_byte8_uint64(s []byte) uint64 {
// arm64:`MOVD\t\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
// amd64:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,-`MOV[BWL]\t[^$]`,-`OR`
// ppc64le:`MOVD\t\(R[0-9]+\)`,-`MOV[BHW]Z`
// arm64:`MOVD \(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
// amd64:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,-`MOV[BWL] [^$]`,-`OR`
// ppc64le:`MOVD \(R[0-9]+\)`,-`MOV[BHW]Z`
// ppc64:`MOVDBR`,-`MOVW[WHB]Z`
return uint64(s[0]) | uint64(s[1])<<8 | uint64(s[2])<<16 | uint64(s[3])<<24 | uint64(s[4])<<32 | uint64(s[5])<<40 | uint64(s[6])<<48 | uint64(s[7])<<56
}
func load_le_byte8_uint64_inv(s []byte) uint64 {
// arm64:`MOVD\t\(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
// arm64:`MOVD \(R[0-9]+\)`,-`ORR`,-`MOV[BHW]`
// ppc64le:`MOVD`,-`MOV[WHB]Z`
// ppc64:`MOVDBR`,-`MOV[WHB]Z`
return uint64(s[7])<<56 | uint64(s[6])<<48 | uint64(s[5])<<40 | uint64(s[4])<<32 | uint64(s[3])<<24 | uint64(s[2])<<16 | uint64(s[1])<<8 | uint64(s[0])
}
func load_be_byte2_uint16(s []byte) uint16 {
// arm64:`MOVHU\t\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
// arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
// amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR`
// ppc64le:`MOVHBR\t\(R[0-9]+\)`,-`MOVBZ`
// ppc64le:`MOVHBR \(R[0-9]+\)`,-`MOVBZ`
// ppc64:`MOVHZ`,-`MOVBZ`
return uint16(s[0])<<8 | uint16(s[1])
}
func load_be_byte2_uint16_inv(s []byte) uint16 {
// arm64:`MOVHU\t\(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
// arm64:`MOVHU \(R[0-9]+\)`,`REV16W`,-`ORR`,-`MOVB`
// amd64:`MOVWLZX\s\([A-Z]+\)`,`ROLW`,-`MOVB`,-`OR`
// ppc64le:`MOVHBR\t\(R[0-9]+\)`,-`MOVBZ`
// ppc64le:`MOVHBR \(R[0-9]+\)`,-`MOVBZ`
// ppc64:`MOVHZ`,-`MOVBZ`
return uint16(s[1]) | uint16(s[0])<<8
}
func load_be_byte4_uint32(s []byte) uint32 {
// arm64:`MOVWU\t\(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
// arm64:`MOVWU \(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
// ppc64le:`MOVWBR`,-`MOV[HB]Z`
// ppc64:`MOVWZ`,-`MOV[HB]Z`
return uint32(s[0])<<24 | uint32(s[1])<<16 | uint32(s[2])<<8 | uint32(s[3])
}
func load_be_byte4_uint32_inv(s []byte) uint32 {
// arm64:`MOVWU\t\(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
// arm64:`MOVWU \(R[0-9]+\)`,`REVW`,-`ORR`,-`REV16W`,-`MOV[BH]`
// amd64/v1,amd64/v2:`MOVL\s\([A-Z]+\)`,`BSWAPL`,-`MOV[BW]`,-`OR`
// amd64/v3: `MOVBEL`
// ppc64le:`MOVWBR`,-`MOV[HB]Z`
@ -217,17 +217,17 @@ func load_be_byte4_uint32_inv(s []byte) uint32 {
}
func load_be_byte8_uint64(s []byte) uint64 {
// arm64:`MOVD\t\(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]`
// ppc64le:`MOVDBR\t\(R[0-9]+\)`,-`MOV[BHW]Z`
// arm64:`MOVD \(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]`
// ppc64le:`MOVDBR \(R[0-9]+\)`,-`MOV[BHW]Z`
// ppc64:`MOVD`,-`MOV[WHB]Z`
return uint64(s[0])<<56 | uint64(s[1])<<48 | uint64(s[2])<<40 | uint64(s[3])<<32 | uint64(s[4])<<24 | uint64(s[5])<<16 | uint64(s[6])<<8 | uint64(s[7])
}
func load_be_byte8_uint64_inv(s []byte) uint64 {
// arm64:`MOVD\t\(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]`
// amd64/v1,amd64/v2:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,`BSWAPQ`,-`MOV[BWL]\t[^$]`,-`OR`
// arm64:`MOVD \(R[0-9]+\)`,`REV`,-`ORR`,-`REVW`,-`REV16W`,-`MOV[BHW]`
// amd64/v1,amd64/v2:`MOVQ\s\([A-Z]+\),\s[A-Z]+`,`BSWAPQ`,-`MOV[BWL] [^$]`,-`OR`
// amd64/v3: `MOVBEQ`
// ppc64le:`MOVDBR\t\(R[0-9]+\)`,-`MOV[BHW]Z`
// ppc64le:`MOVDBR \(R[0-9]+\)`,-`MOV[BHW]Z`
// ppc64:`MOVD`,-`MOV[BHW]Z`
return uint64(s[7]) | uint64(s[6])<<8 | uint64(s[5])<<16 | uint64(s[4])<<24 | uint64(s[3])<<32 | uint64(s[2])<<40 | uint64(s[1])<<48 | uint64(s[0])<<56
}
@ -386,20 +386,20 @@ func fcall_uint32(a [2]uint32) [2]uint32 {
// We want to merge load+op in the first function, but not in the
// second. See Issue 19595.
func load_op_merge(p, q *int) {
x := *p // amd64:`ADDQ\t\(`
x := *p // amd64:`ADDQ \(`
*q += x // The combined nilcheck and load would normally have this line number, but we want that combined operation to have the line number of the nil check instead (see #33724).
}
func load_op_no_merge(p, q *int) {
x := *p
for i := 0; i < 10; i++ {
*q += x // amd64:`ADDQ\t[A-Z]`
*q += x // amd64:`ADDQ [A-Z]`
}
}
func load_op_in_loop(a []int) int {
r := 0
for _, x := range a {
// amd64:`ADDQ\t\([A-Z]+\)\([A-Z]+\*8\), [A-Z]+`
// amd64:`ADDQ \([A-Z]+\)\([A-Z]+\*8\), [A-Z]+`
r += x
}
return r
@ -407,7 +407,7 @@ func load_op_in_loop(a []int) int {
// Make sure offsets are folded into loads and stores.
func offsets_fold(_, a [20]byte) (b [20]byte) {
// arm64:`MOVD\tcommand-line-arguments\.a\+[0-9]+\(FP\), R[0-9]+`,`MOVD\tR[0-9]+, command-line-arguments\.b\+[0-9]+\(FP\)`
// arm64:`MOVD command-line-arguments\.a\+[0-9]+\(FP\), R[0-9]+`,`MOVD R[0-9]+, command-line-arguments\.b\+[0-9]+\(FP\)`
b = a
return
}
@ -526,7 +526,7 @@ func store_be64(b []byte, x uint64) {
func store_be64_idx(b []byte, x uint64, idx int) {
// amd64/v1,amd64/v2:`BSWAPQ`,-`SHR.`
// amd64/v3:`MOVBEQ\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// amd64/v3:`MOVBEQ [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// arm64:`REV`,`MOVD\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BHW]`,-`REV16W`,-`REVW`
// ppc64le:`MOVDBR`
// ppc64:`MOVD\s`
@ -558,7 +558,7 @@ func store_be32_load(b, x *[8]byte) {
func store_be32_idx(b []byte, x uint32, idx int) {
// amd64/v1,amd64/v2:`BSWAPL`,-`SHR.`
// amd64/v3:`MOVBEL\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// amd64/v3:`MOVBEL [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// arm64:`REVW`,`MOVW\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,-`MOV[BH]`,-`REV16W`
// ppc64le:`MOVWBR`
// ppc64:`MOVW\s`
@ -578,7 +578,7 @@ func store_be16(b []byte, x uint16) {
func store_be16_idx(b []byte, x uint16, idx int) {
// amd64/v1,amd64/v2:`ROLW\s\$8`,-`SHR.`
// amd64/v3:`MOVBEW\t[A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// amd64/v3:`MOVBEW [A-Z]+[0-9]*, \([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// arm64:`MOVH\sR[0-9]+,\s\(R[0-9]+\)\(R[0-9]+\)`,`REV16W`,-`MOVB`
// ppc64le:`MOVHBR`
// ppc64:`MOVH\s`
@ -736,12 +736,12 @@ func store_le_byte_4_idx4_inv(b []byte, idx int, val uint32) {
func zero_byte_2(b1, b2 []byte) {
// bounds checks to guarantee safety of writes below
_, _ = b1[1], b2[1]
// arm64:"MOVH\tZR",-"MOVB"
// arm64:"MOVH ZR" -"MOVB"
// amd64:`MOVW\s[$]0,\s\([A-Z]+\)`
// 386:`MOVW\s[$]0,\s\([A-Z]+\)`
// ppc64x:`MOVH\s`
b1[0], b1[1] = 0, 0
// arm64:"MOVH\tZR",-"MOVB"
// arm64:"MOVH ZR" -"MOVB"
// 386:`MOVW\s[$]0,\s\([A-Z]+\)`
// amd64:`MOVW\s[$]0,\s\([A-Z]+\)`
// ppc64x:`MOVH`
@ -750,36 +750,36 @@ func zero_byte_2(b1, b2 []byte) {
func zero_byte_4(b1, b2 []byte) {
_, _ = b1[3], b2[3]
// arm64:"MOVW\tZR",-"MOVB",-"MOVH"
// arm64:"MOVW ZR" -"MOVB" -"MOVH"
// amd64:`MOVL\s[$]0,\s\([A-Z]+\)`
// 386:`MOVL\s[$]0,\s\([A-Z]+\)`
// ppc64x:`MOVW\s`
b1[0], b1[1], b1[2], b1[3] = 0, 0, 0, 0
// arm64:"MOVW\tZR",-"MOVB",-"MOVH"
// arm64:"MOVW ZR" -"MOVB" -"MOVH"
// ppc64x:`MOVW\s`
b2[2], b2[3], b2[1], b2[0] = 0, 0, 0, 0
}
func zero_byte_8(b []byte) {
_ = b[7]
b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
b[4], b[5], b[6], b[7] = 0, 0, 0, 0
}
func zero_byte_16(b []byte) {
_ = b[15]
b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH",-"MOVW"
b[0], b[1], b[2], b[3] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH" -"MOVW"
b[4], b[5], b[6], b[7] = 0, 0, 0, 0
b[8], b[9], b[10], b[11] = 0, 0, 0, 0
b[12], b[13], b[14], b[15] = 0, 0, 0, 0
}
func zero_byte_30(a *[30]byte) {
*a = [30]byte{} // arm64:"STP",-"MOVB",-"MOVH",-"MOVW"
*a = [30]byte{} // arm64:"STP" -"MOVB" -"MOVH" -"MOVW"
}
func zero_byte_39(a *[39]byte) {
*a = [39]byte{} // arm64:"MOVD",-"MOVB",-"MOVH",-"MOVW"
*a = [39]byte{} // arm64:"MOVD" -"MOVB" -"MOVH" -"MOVW"
}
func zero_byte_2_idx(b []byte, idx int) {
@ -798,12 +798,12 @@ func zero_byte_2_idx2(b []byte, idx int) {
func zero_uint16_2(h1, h2 []uint16) {
_, _ = h1[1], h2[1]
// arm64:"MOVW\tZR",-"MOVB",-"MOVH"
// arm64:"MOVW ZR" -"MOVB" -"MOVH"
// amd64:`MOVL\s[$]0,\s\([A-Z]+\)`
// 386:`MOVL\s[$]0,\s\([A-Z]+\)`
// ppc64x:`MOVW\s`
h1[0], h1[1] = 0, 0
// arm64:"MOVW\tZR",-"MOVB",-"MOVH"
// arm64:"MOVW ZR" -"MOVB" -"MOVH"
// amd64:`MOVL\s[$]0,\s\([A-Z]+\)`
// 386:`MOVL\s[$]0,\s\([A-Z]+\)`
// ppc64x:`MOVW`
@ -812,28 +812,28 @@ func zero_uint16_2(h1, h2 []uint16) {
func zero_uint16_4(h1, h2 []uint16) {
_, _ = h1[3], h2[3]
// arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
// arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
// amd64:`MOVQ\s[$]0,\s\([A-Z]+\)`
// ppc64x:`MOVD\s`
h1[0], h1[1], h1[2], h1[3] = 0, 0, 0, 0
// arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
// arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
// ppc64x:`MOVD\s`
h2[2], h2[3], h2[1], h2[0] = 0, 0, 0, 0
}
func zero_uint16_8(h []uint16) {
_ = h[7]
h[0], h[1], h[2], h[3] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
h[0], h[1], h[2], h[3] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
h[4], h[5], h[6], h[7] = 0, 0, 0, 0
}
func zero_uint32_2(w1, w2 []uint32) {
_, _ = w1[1], w2[1]
// arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
// arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
// amd64:`MOVQ\s[$]0,\s\([A-Z]+\)`
// ppc64x:`MOVD\s`
w1[0], w1[1] = 0, 0
// arm64:"MOVD\tZR",-"MOVB",-"MOVH",-"MOVW"
// arm64:"MOVD ZR" -"MOVB" -"MOVH" -"MOVW"
// amd64:`MOVQ\s[$]0,\s\([A-Z]+\)`
// ppc64x:`MOVD\s`
w2[1], w2[0] = 0, 0
@ -841,22 +841,22 @@ func zero_uint32_2(w1, w2 []uint32) {
func zero_uint32_4(w1, w2 []uint32) {
_, _ = w1[3], w2[3]
w1[0], w1[1], w1[2], w1[3] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
w2[2], w2[3], w2[1], w2[0] = 0, 0, 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
w1[0], w1[1], w1[2], w1[3] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
w2[2], w2[3], w2[1], w2[0] = 0, 0, 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
}
func zero_uint64_2(d1, d2 []uint64) {
_, _ = d1[1], d2[1]
d1[0], d1[1] = 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
d2[1], d2[0] = 0, 0 // arm64:"STP",-"MOVB",-"MOVH"
d1[0], d1[1] = 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
d2[1], d2[0] = 0, 0 // arm64:"STP" -"MOVB" -"MOVH"
}
func loadstore(p, q *[4]uint8) {
// amd64:"MOVL",-"MOVB"
// arm64:"MOVWU",-"MOVBU"
// amd64:"MOVL" -"MOVB"
// arm64:"MOVWU" -"MOVBU"
x0, x1, x2, x3 := q[0], q[1], q[2], q[3]
// amd64:"MOVL",-"MOVB"
// arm64:"MOVW",-"MOVB"
// amd64:"MOVL" -"MOVB"
// arm64:"MOVW" -"MOVB"
p[0], p[1], p[2], p[3] = x0, x1, x2, x3
}
@ -865,11 +865,11 @@ type S1 struct {
}
func loadstore2(p, q *S1) {
// amd64:"MOVL",-"MOVWLZX"
// arm64:"MOVWU",-"MOVH"
// amd64:"MOVL" -"MOVWLZX"
// arm64:"MOVWU" -"MOVH"
a, b := p.a, p.b
// amd64:"MOVL",-"MOVW"
// arm64:"MOVW",-"MOVH"
// amd64:"MOVL" -"MOVW"
// arm64:"MOVW" -"MOVH"
q.a, q.b = a, b
}
@ -878,11 +878,11 @@ func wideStore(p *[8]uint64) {
return
}
// amd64:"MOVUPS",-"MOVQ"
// arm64:"STP",-"MOVD"
// amd64:"MOVUPS" -"MOVQ"
// arm64:"STP" -"MOVD"
p[0] = 0
// amd64:-"MOVUPS",-"MOVQ"
// arm64:-"STP",-"MOVD"
// amd64:-"MOVUPS" -"MOVQ"
// arm64:-"STP" -"MOVD"
p[1] = 0
}
@ -893,52 +893,52 @@ func wideStore2(p *[8]uint64, x, y uint64) {
// s390x:"STMG"
p[0] = x
// s390x:-"STMG",-"MOVD"
// s390x:-"STMG" -"MOVD"
p[1] = y
}
func store32le(p *struct{ a, b uint32 }, x uint64) {
// amd64:"MOVQ",-"MOVL",-"SHRQ"
// arm64:"MOVD",-"MOVW",-"LSR"
// ppc64le:"MOVD",-"MOVW",-"SRD"
// amd64:"MOVQ" -"MOVL" -"SHRQ"
// arm64:"MOVD" -"MOVW" -"LSR"
// ppc64le:"MOVD" -"MOVW" -"SRD"
p.a = uint32(x)
// amd64:-"MOVL",-"SHRQ"
// arm64:-"MOVW",-"LSR"
// ppc64le:-"MOVW",-"SRD"
// amd64:-"MOVL" -"SHRQ"
// arm64:-"MOVW" -"LSR"
// ppc64le:-"MOVW" -"SRD"
p.b = uint32(x >> 32)
}
func store32be(p *struct{ a, b uint32 }, x uint64) {
// arm64:"STPW"
// ppc64:"MOVD",-"MOVW",-"SRD"
// s390x:"MOVD",-"MOVW",-"SRD"
// ppc64:"MOVD" -"MOVW" -"SRD"
// s390x:"MOVD" -"MOVW" -"SRD"
p.a = uint32(x >> 32)
// arm64:-"STPW"
// ppc64:-"MOVW",-"SRD"
// s390x:-"MOVW",-"SRD"
// ppc64:-"MOVW" -"SRD"
// s390x:-"MOVW" -"SRD"
p.b = uint32(x)
}
func store16le(p *struct{ a, b uint16 }, x uint32) {
// amd64:"MOVL",-"MOVW",-"SHRL"
// arm64:"MOVW",-"MOVH",-"UBFX"
// ppc64le:"MOVW",-"MOVH",-"SRW"
// amd64:"MOVL" -"MOVW" -"SHRL"
// arm64:"MOVW" -"MOVH" -"UBFX"
// ppc64le:"MOVW" -"MOVH" -"SRW"
p.a = uint16(x)
// amd64:-"MOVW",-"SHRL"
// arm64:-"MOVH",-"UBFX"
// ppc64le:-"MOVH",-"SRW"
// amd64:-"MOVW" -"SHRL"
// arm64:-"MOVH" -"UBFX"
// ppc64le:-"MOVH" -"SRW"
p.b = uint16(x >> 16)
}
func store16be(p *struct{ a, b uint16 }, x uint32) {
// ppc64:"MOVW",-"MOVH",-"SRW"
// s390x:"MOVW",-"MOVH",-"SRW"
// ppc64:"MOVW" -"MOVH" -"SRW"
// s390x:"MOVW" -"MOVH" -"SRW"
p.a = uint16(x >> 16)
// ppc64:-"MOVH",-"SRW"
// s390x:-"MOVH",-"SRW"
// ppc64:-"MOVH" -"SRW"
// s390x:-"MOVH" -"SRW"
p.b = uint16(x)
}
func storeBoolConst(p *struct{ a, b bool }) {
// amd64:"MOVW",-"MOVB"
// arm64:"MOVH",-"MOVB"
// amd64:"MOVW" -"MOVB"
// arm64:"MOVH" -"MOVB"
p.a = true
p.b = true
}
@ -948,8 +948,8 @@ func issue66413(p *struct {
c bool
d int8
}) {
// amd64:"MOVL",-"MOVB"
// arm64:"MOVW",-"MOVB"
// amd64:"MOVL" -"MOVB"
// arm64:"MOVW" -"MOVB"
p.a = 31
p.b = false
p.c = true
@ -957,7 +957,7 @@ func issue66413(p *struct {
}
func issue70300(v uint64) (b [8]byte) {
// amd64:"MOVQ",-"MOVB"
// amd64:"MOVQ" -"MOVB"
b[0] = byte(v)
b[1] = byte(v >> 8)
b[2] = byte(v >> 16)
@ -970,7 +970,7 @@ func issue70300(v uint64) (b [8]byte) {
}
func issue70300Reverse(v uint64) (b [8]byte) {
// amd64:"MOVQ",-"MOVB"
// amd64:"MOVQ" -"MOVB"
b[7] = byte(v >> 56)
b[6] = byte(v >> 48)
b[5] = byte(v >> 40)
@ -987,43 +987,43 @@ func issue70300Reverse(v uint64) (b [8]byte) {
// --------------------------------- //
func dwloadI64(p *struct{ a, b int64 }) int64 {
// arm64:"LDP\t"
// arm64:"LDP "
return p.a + p.b
}
func dwloadI32(p *struct{ a, b int32 }) int32 {
// arm64:"LDPSW\t"
// arm64:"LDPSW "
return p.a + p.b
}
func dwloadU32(p *struct{ a, b uint32 }) uint32 {
// arm64:"LDPW\t"
// arm64:"LDPW "
return p.a + p.b
}
func dwloadF64(p *struct{ a, b float64 }) float64 {
// arm64:"FLDPD\t"
// arm64:"FLDPD "
return p.a + p.b
}
func dwloadF32(p *struct{ a, b float32 }) float32 {
// arm64:"FLDPS\t"
// arm64:"FLDPS "
return p.a + p.b
}
func dwloadBig(p *struct{ a, b, c, d, e, f int64 }) int64 {
// arm64:"LDP\t\\(", "LDP\t16", "LDP\t32"
// arm64:"LDP \\(", "LDP 16", "LDP 32"
return p.c + p.f + p.a + p.e + p.d + p.b
}
func dwloadArg(a [2]int64) int64 {
// arm64:"LDP\t"
// arm64:"LDP "
return a[0] + a[1]
}
func dwloadResult1(p *string) string {
// arm64:"LDP\t\\(R0\\), \\(R0, R1\\)"
// arm64:"LDP \\(R0\\), \\(R0, R1\\)"
return *p
}
func dwloadResult2(p *[2]int64) (int64, int64) {
// arm64:"LDP\t\\(R0\\), \\(R1, R0\\)"
// arm64:"LDP \\(R0\\), \\(R1, R0\\)"
return p[1], p[0]
}
@ -1032,22 +1032,22 @@ func dwloadResult2(p *[2]int64) (int64, int64) {
// ---------------------------------- //
func dwstoreI64(p *struct{ a, b int64 }, x, y int64) {
// arm64:"STP\t"
// arm64:"STP "
p.a = x
p.b = y
}
func dwstoreI32(p *struct{ a, b int32 }, x, y int32) {
// arm64:"STPW\t"
// arm64:"STPW "
p.a = x
p.b = y
}
func dwstoreF64(p *struct{ a, b float64 }, x, y float64) {
// arm64:"FSTPD\t"
// arm64:"FSTPD "
p.a = x
p.b = y
}
func dwstoreF32(p *struct{ a, b float32 }, x, y float32) {
// arm64:"FSTPS\t"
// arm64:"FSTPS "
p.a = x
p.b = y
}
@ -1065,14 +1065,14 @@ func dwstoreBig(p *struct{ a, b, c, d, e, f int64 }, a, b, c, d, e, f int64) {
}
func dwstoreRet() [2]int {
// arm64:"STP\t"
// arm64:"STP "
return [2]int{5, 6}
}
func dwstoreLocal(i int) int64 {
var a [2]int64
a[0] = 5
// arm64:"STP\t"
// arm64:"STP "
a[1] = 6
return a[i]
}
@ -1081,7 +1081,7 @@ func dwstoreOrder(p *struct {
a, b int64
c, d, e, f bool
}, a, b int64) {
// arm64:"STP\t"
// arm64:"STP "
p.a = a
p.c = true
p.e = true

298
test/codegen/memops.go
View file

@ -13,23 +13,23 @@ var x32 [2]uint32
var x64 [2]uint64
func compMem1() int {
// amd64:`CMPB\tcommand-line-arguments.x\+1\(SB\), [$]0`
// amd64:`CMPB command-line-arguments.x\+1\(SB\), [$]0`
if x[1] {
return 1
}
// amd64:`CMPB\tcommand-line-arguments.x8\+1\(SB\), [$]7`
// amd64:`CMPB command-line-arguments.x8\+1\(SB\), [$]7`
if x8[1] == 7 {
return 1
}
// amd64:`CMPW\tcommand-line-arguments.x16\+2\(SB\), [$]7`
// amd64:`CMPW command-line-arguments.x16\+2\(SB\), [$]7`
if x16[1] == 7 {
return 1
}
// amd64:`CMPL\tcommand-line-arguments.x32\+4\(SB\), [$]7`
// amd64:`CMPL command-line-arguments.x32\+4\(SB\), [$]7`
if x32[1] == 7 {
return 1
}
// amd64:`CMPQ\tcommand-line-arguments.x64\+8\(SB\), [$]7`
// amd64:`CMPQ command-line-arguments.x64\+8\(SB\), [$]7`
if x64[1] == 7 {
return 1
}
@ -46,23 +46,23 @@ type T struct {
}
func compMem2(t T) int {
// amd64:`CMPB\t.*\(SP\), [$]0`
// amd64:`CMPB .*\(SP\), [$]0`
if t.x {
return 1
}
// amd64:`CMPB\t.*\(SP\), [$]7`
// amd64:`CMPB .*\(SP\), [$]7`
if t.x8 == 7 {
return 1
}
// amd64:`CMPW\t.*\(SP\), [$]7`
// amd64:`CMPW .*\(SP\), [$]7`
if t.x16 == 7 {
return 1
}
// amd64:`CMPL\t.*\(SP\), [$]7`
// amd64:`CMPL .*\(SP\), [$]7`
if t.x32 == 7 {
return 1
}
// amd64:`CMPQ\t.*\(SP\), [$]7`
// amd64:`CMPQ .*\(SP\), [$]7`
if t.x64 == 7 {
return 1
}
@ -73,8 +73,8 @@ func compMem3(x, y *int) (int, bool) {
// We can do comparisons of a register with memory even if
// the register is used subsequently.
r := *x
// amd64:`CMPQ\t\(`
// 386:`CMPL\t\(`
// amd64:`CMPQ \(`
// 386:`CMPL \(`
return r, r < *y
}
@ -82,261 +82,261 @@ func compMem3(x, y *int) (int, bool) {
func idxInt8(x, y []int8, i int) {
var t int8
// amd64: `MOVBL[SZ]X\t1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
// 386: `MOVBL[SZ]X\t1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
// amd64: `MOVBL[SZ]X 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
// 386: `MOVBL[SZ]X 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
t = x[i+1]
// amd64: `MOVB\t[A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// 386: `MOVB\t[A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// amd64: `MOVB [A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// 386: `MOVB [A-Z]+[0-9]*, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
y[i+1] = t
// amd64: `MOVB\t[$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// 386: `MOVB\t[$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// amd64: `MOVB [$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// 386: `MOVB [$]77, 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
x[i+1] = 77
}
func idxInt16(x, y []int16, i int) {
var t int16
// amd64: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
// 386: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
// amd64: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
// 386: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
t = x[i+1]
// amd64: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
// 386: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
// amd64: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
// 386: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
y[i+1] = t
// amd64: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
// 386: `MOVWL[SZ]X\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
// amd64: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
// 386: `MOVWL[SZ]X 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
t = x[16*i+1]
// amd64: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
// 386: `MOVW\t[A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
// amd64: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
// 386: `MOVW [A-Z]+[0-9]*, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
y[16*i+1] = t
// amd64: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
// 386: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
// amd64: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
// 386: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\)`
x[i+1] = 77
// amd64: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
// 386: `MOVW\t[$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
// amd64: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
// 386: `MOVW [$]77, 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\)`
x[16*i+1] = 77
}
func idxInt32(x, y []int32, i int) {
var t int32
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// 386: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// 386: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
t = x[i+1]
// amd64: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
y[i+1] = t
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
t = x[2*i+1]
// amd64: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
y[2*i+1] = t
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
// 386: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
// 386: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
t = x[16*i+1]
// amd64: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
// 386: `MOVL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
// amd64: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
// 386: `MOVL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
y[16*i+1] = t
// amd64: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// amd64: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+1] = 77
// amd64: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
// 386: `MOVL\t[$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
// amd64: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
// 386: `MOVL [$]77, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
x[16*i+1] = 77
}
func idxInt64(x, y []int64, i int) {
var t int64
// amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
t = x[i+1]
// amd64: `MOVQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `MOVQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
y[i+1] = t
// amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
t = x[16*i+1]
// amd64: `MOVQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
// amd64: `MOVQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
y[16*i+1] = t
// amd64: `MOVQ\t[$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `MOVQ [$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+1] = 77
// amd64: `MOVQ\t[$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
// amd64: `MOVQ [$]77, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
x[16*i+1] = 77
}
func idxFloat32(x, y []float32, i int) {
var t float32
// amd64: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
// 386/sse2: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
// arm64: `FMOVS\t\(R[0-9]*\)\(R[0-9]*<<2\), F[0-9]+`
// amd64: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
// 386/sse2: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
// arm64: `FMOVS \(R[0-9]*\)\(R[0-9]*<<2\), F[0-9]+`
t = x[i+1]
// amd64: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386/sse2: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// arm64: `FMOVS\tF[0-9]+, \(R[0-9]*\)\(R[0-9]*<<2\)`
// amd64: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386/sse2: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// arm64: `FMOVS F[0-9]+, \(R[0-9]*\)\(R[0-9]*<<2\)`
y[i+1] = t
// amd64: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
// 386/sse2: `MOVSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
// amd64: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
// 386/sse2: `MOVSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), X[0-9]+`
t = x[16*i+1]
// amd64: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
// 386/sse2: `MOVSS\tX[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
// amd64: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
// 386/sse2: `MOVSS X[0-9]+, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\)`
y[16*i+1] = t
}
func idxFloat64(x, y []float64, i int) {
var t float64
// amd64: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
// 386/sse2: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
// arm64: `FMOVD\t\(R[0-9]*\)\(R[0-9]*<<3\), F[0-9]+`
// amd64: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
// 386/sse2: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
// arm64: `FMOVD \(R[0-9]*\)\(R[0-9]*<<3\), F[0-9]+`
t = x[i+1]
// amd64: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// 386/sse2: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// arm64: `FMOVD\tF[0-9]+, \(R[0-9]*\)\(R[0-9]*<<3\)`
// amd64: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// 386/sse2: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// arm64: `FMOVD F[0-9]+, \(R[0-9]*\)\(R[0-9]*<<3\)`
y[i+1] = t
// amd64: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
// 386/sse2: `MOVSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
// amd64: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
// 386/sse2: `MOVSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), X[0-9]+`
t = x[16*i+1]
// amd64: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
// 386/sse2: `MOVSD\tX[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
// amd64: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
// 386/sse2: `MOVSD X[0-9]+, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\)`
y[16*i+1] = t
}
func idxLoadPlusOp32(x []int32, i int) int32 {
s := x[0]
// 386: `ADDL\t4\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `ADDL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// 386: `ADDL 4\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `ADDL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
s += x[i+1]
// 386: `SUBL\t8\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `SUBL\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// 386: `SUBL 8\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `SUBL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
s -= x[i+2]
// 386: `IMULL\t12\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// 386: `IMULL 12\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
s *= x[i+3]
// 386: `ANDL\t16\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `ANDL\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// 386: `ANDL 16\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `ANDL 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
s &= x[i+4]
// 386: `ORL\t20\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `ORL\t20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// 386: `ORL 20\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `ORL 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
s |= x[i+5]
// 386: `XORL\t24\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `XORL\t24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// 386: `XORL 24\([A-Z]+\)\([A-Z]+\*4\), [A-Z]+`
// amd64: `XORL 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
s ^= x[i+6]
return s
}
func idxLoadPlusOp64(x []int64, i int) int64 {
s := x[0]
// amd64: `ADDQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64: `ADDQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
s += x[i+1]
// amd64: `SUBQ\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64: `SUBQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
s -= x[i+2]
// amd64: `ANDQ\t24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64: `ANDQ 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
s &= x[i+3]
// amd64: `ORQ\t32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64: `ORQ 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
s |= x[i+4]
// amd64: `XORQ\t40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64: `XORQ 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
s ^= x[i+5]
return s
}
func idxStorePlusOp32(x []int32, i int, v int32) {
// 386: `ADDL\t[A-Z]+, 4\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ADDL\t[A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `ADDL [A-Z]+, 4\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ADDL [A-Z]+[0-9]*, 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+1] += v
// 386: `SUBL\t[A-Z]+, 8\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `SUBL\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `SUBL [A-Z]+, 8\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `SUBL [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+2] -= v
// 386: `ANDL\t[A-Z]+, 12\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ANDL\t[A-Z]+[0-9]*, 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `ANDL [A-Z]+, 12\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ANDL [A-Z]+[0-9]*, 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+3] &= v
// 386: `ORL\t[A-Z]+, 16\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ORL\t[A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `ORL [A-Z]+, 16\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ORL [A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+4] |= v
// 386: `XORL\t[A-Z]+, 20\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `XORL\t[A-Z]+[0-9]*, 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `XORL [A-Z]+, 20\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `XORL [A-Z]+[0-9]*, 20\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+5] ^= v
// 386: `ADDL\t[$]77, 24\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ADDL\t[$]77, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `ADDL [$]77, 24\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ADDL [$]77, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+6] += 77
// 386: `ANDL\t[$]77, 28\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ANDL\t[$]77, 28\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `ANDL [$]77, 28\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ANDL [$]77, 28\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+7] &= 77
// 386: `ORL\t[$]77, 32\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ORL\t[$]77, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `ORL [$]77, 32\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `ORL [$]77, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+8] |= 77
// 386: `XORL\t[$]77, 36\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `XORL\t[$]77, 36\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
// 386: `XORL [$]77, 36\([A-Z]+\)\([A-Z]+\*4\)`
// amd64: `XORL [$]77, 36\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\)`
x[i+9] ^= 77
}
func idxStorePlusOp64(x []int64, i int, v int64) {
// amd64: `ADDQ\t[A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `ADDQ [A-Z]+[0-9]*, 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+1] += v
// amd64: `SUBQ\t[A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `SUBQ [A-Z]+[0-9]*, 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+2] -= v
// amd64: `ANDQ\t[A-Z]+[0-9]*, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `ANDQ [A-Z]+[0-9]*, 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+3] &= v
// amd64: `ORQ\t[A-Z]+[0-9]*, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `ORQ [A-Z]+[0-9]*, 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+4] |= v
// amd64: `XORQ\t[A-Z]+[0-9]*, 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `XORQ [A-Z]+[0-9]*, 40\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+5] ^= v
// amd64: `ADDQ\t[$]77, 48\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `ADDQ [$]77, 48\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+6] += 77
// amd64: `ANDQ\t[$]77, 56\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `ANDQ [$]77, 56\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+7] &= 77
// amd64: `ORQ\t[$]77, 64\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `ORQ [$]77, 64\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+8] |= 77
// amd64: `XORQ\t[$]77, 72\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
// amd64: `XORQ [$]77, 72\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\)`
x[i+9] ^= 77
}
func idxCompare(i int) int {
// amd64: `MOVBLZX\t1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
// amd64: `MOVBLZX 1\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
if x8[i+1] < x8[0] {
return 0
}
// amd64: `MOVWLZX\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
// amd64: `MOVWLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
if x16[i+1] < x16[0] {
return 0
}
// amd64: `MOVWLZX\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
// amd64: `MOVWLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
if x16[16*i+1] < x16[0] {
return 0
}
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
if x32[i+1] < x32[0] {
return 0
}
// amd64: `MOVL\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
// amd64: `MOVL 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
if x32[16*i+1] < x32[0] {
return 0
}
// amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
if x64[i+1] < x64[0] {
return 0
}
// amd64: `MOVQ\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
// amd64: `MOVQ 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
if x64[16*i+1] < x64[0] {
return 0
}
// amd64: `MOVBLZX\t2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
// amd64: `MOVBLZX 2\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\), [A-Z]+[0-9]*`
if x8[i+2] < 77 {
return 0
}
// amd64: `MOVWLZX\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
// amd64: `MOVWLZX 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*2\), [A-Z]+[0-9]*`
if x16[i+2] < 77 {
return 0
}
// amd64: `MOVWLZX\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
// amd64: `MOVWLZX 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[12]\), [A-Z]+[0-9]*`
if x16[16*i+2] < 77 {
return 0
}
// amd64: `MOVL\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
// amd64: `MOVL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), [A-Z]+[0-9]*`
if x32[i+2] < 77 {
return 0
}
// amd64: `MOVL\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
// amd64: `MOVL 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[14]\), [A-Z]+[0-9]*`
if x32[16*i+2] < 77 {
return 0
}
// amd64: `MOVQ\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
// amd64: `MOVQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), [A-Z]+[0-9]*`
if x64[i+2] < 77 {
return 0
}
// amd64: `MOVQ\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
// amd64: `MOVQ 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*[18]\), [A-Z]+[0-9]*`
if x64[16*i+2] < 77 {
return 0
}
@ -345,59 +345,59 @@ func idxCompare(i int) int {
func idxFloatOps(a []float64, b []float32, i int) (float64, float32) {
c := float64(7)
// amd64: `ADDSD\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
// amd64: `ADDSD 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
c += a[i+1]
// amd64: `SUBSD\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
// amd64: `SUBSD 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
c -= a[i+2]
// amd64: `MULSD\t24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
// amd64: `MULSD 24\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
c *= a[i+3]
// amd64: `DIVSD\t32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
// amd64: `DIVSD 32\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*8\), X[0-9]+`
c /= a[i+4]
d := float32(8)
// amd64: `ADDSS\t4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
// amd64: `ADDSS 4\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
d += b[i+1]
// amd64: `SUBSS\t8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
// amd64: `SUBSS 8\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
d -= b[i+2]
// amd64: `MULSS\t12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
// amd64: `MULSS 12\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
d *= b[i+3]
// amd64: `DIVSS\t16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
// amd64: `DIVSS 16\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*4\), X[0-9]+`
d /= b[i+4]
return c, d
}
func storeTest(a []bool, v int, i int) {
// amd64: `BTL\t\$0,`,`SETCS\t4\([A-Z]+[0-9]*\)`
// amd64: `BTL \$0,`,`SETCS 4\([A-Z]+[0-9]*\)`
a[4] = v&1 != 0
// amd64: `BTL\t\$1,`,`SETCS\t3\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
// amd64: `BTL \$1,`,`SETCS 3\([A-Z]+[0-9]*\)\([A-Z]+[0-9]*\*1\)`
a[3+i] = v&2 != 0
}
func bitOps(p *[12]uint64) {
// amd64: `ORQ\t\$8, \(AX\)`
// amd64: `ORQ \$8, \(AX\)`
p[0] |= 8
// amd64: `ORQ\t\$1073741824, 8\(AX\)`
// amd64: `ORQ \$1073741824, 8\(AX\)`
p[1] |= 1 << 30
// amd64: `BTSQ\t\$31, 16\(AX\)`
// amd64: `BTSQ \$31, 16\(AX\)`
p[2] |= 1 << 31
// amd64: `BTSQ\t\$63, 24\(AX\)`
// amd64: `BTSQ \$63, 24\(AX\)`
p[3] |= 1 << 63
// amd64: `ANDQ\t\$-9, 32\(AX\)`
// amd64: `ANDQ \$-9, 32\(AX\)`
p[4] &^= 8
// amd64: `ANDQ\t\$-1073741825, 40\(AX\)`
// amd64: `ANDQ \$-1073741825, 40\(AX\)`
p[5] &^= 1 << 30
// amd64: `BTRQ\t\$31, 48\(AX\)`
// amd64: `BTRQ \$31, 48\(AX\)`
p[6] &^= 1 << 31
// amd64: `BTRQ\t\$63, 56\(AX\)`
// amd64: `BTRQ \$63, 56\(AX\)`
p[7] &^= 1 << 63
// amd64: `XORQ\t\$8, 64\(AX\)`
// amd64: `XORQ \$8, 64\(AX\)`
p[8] ^= 8
// amd64: `XORQ\t\$1073741824, 72\(AX\)`
// amd64: `XORQ \$1073741824, 72\(AX\)`
p[9] ^= 1 << 30
// amd64: `BTCQ\t\$31, 80\(AX\)`
// amd64: `BTCQ \$31, 80\(AX\)`
p[10] ^= 1 << 31
// amd64: `BTCQ\t\$63, 88\(AX\)`
// amd64: `BTCQ \$63, 88\(AX\)`
p[11] ^= 1 << 63
}

348
test/codegen/multiply.go
View file

@ -11,8 +11,8 @@ package codegen
func m0(x int64) int64 {
// amd64: "XORL"
// arm64: "MOVD\tZR"
// loong64: "MOVV\tR0"
// arm64: "MOVD ZR"
// loong64: "MOVV R0"
return x * 0
}
func m2(x int64) int64 {
@ -22,351 +22,351 @@ func m2(x int64) int64 {
return x * 2
}
func m3(x int64) int64 {
// amd64: "LEAQ\t.*[*]2"
// arm64: "ADD\tR[0-9]+<<1,"
// loong64: "ALSLV\t[$]1,"
// amd64: "LEAQ .*[*]2"
// arm64: "ADD R[0-9]+<<1,"
// loong64: "ALSLV [$]1,"
return x * 3
}
func m4(x int64) int64 {
// amd64: "SHLQ\t[$]2,"
// arm64: "LSL\t[$]2,"
// loong64: "SLLV\t[$]2,"
// amd64: "SHLQ [$]2,"
// arm64: "LSL [$]2,"
// loong64: "SLLV [$]2,"
return x * 4
}
func m5(x int64) int64 {
// amd64: "LEAQ\t.*[*]4"
// arm64: "ADD\tR[0-9]+<<2,"
// loong64: "ALSLV\t[$]2,"
// amd64: "LEAQ .*[*]4"
// arm64: "ADD R[0-9]+<<2,"
// loong64: "ALSLV [$]2,"
return x * 5
}
func m6(x int64) int64 {
// amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]2"
// arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<1,"
// amd64: "LEAQ .*[*]1", "LEAQ .*[*]2"
// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<1,"
// loong64: "ADDVU", "ADDVU", "ADDVU"
return x * 6
}
func m7(x int64) int64 {
// amd64: "LEAQ\t.*[*]2"
// arm64: "LSL\t[$]3,", "SUB\tR[0-9]+,"
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]1,"
// amd64: "LEAQ .*[*]2"
// arm64: "LSL [$]3,", "SUB R[0-9]+,"
// loong64: "ALSLV [$]1,", "ALSLV [$]1,"
return x * 7
}
func m8(x int64) int64 {
// amd64: "SHLQ\t[$]3,"
// arm64: "LSL\t[$]3,"
// loong64: "SLLV\t[$]3,"
// amd64: "SHLQ [$]3,"
// arm64: "LSL [$]3,"
// loong64: "SLLV [$]3,"
return x * 8
}
func m9(x int64) int64 {
// amd64: "LEAQ\t.*[*]8"
// arm64: "ADD\tR[0-9]+<<3,"
// loong64: "ALSLV\t[$]3,"
// amd64: "LEAQ .*[*]8"
// arm64: "ADD R[0-9]+<<3,"
// loong64: "ALSLV [$]3,"
return x * 9
}
func m10(x int64) int64 {
// amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]4"
// arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<2,"
// loong64: "ADDVU", "ALSLV\t[$]2,"
// amd64: "LEAQ .*[*]1", "LEAQ .*[*]4"
// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<2,"
// loong64: "ADDVU", "ALSLV [$]2,"
return x * 10
}
func m11(x int64) int64 {
// amd64: "LEAQ\t.*[*]4", "LEAQ\t.*[*]2"
// arm64: "MOVD\t[$]11,", "MUL"
// loong64: "ALSLV\t[$]2,", "ALSLV\t[$]1,"
// amd64: "LEAQ .*[*]4", "LEAQ .*[*]2"
// arm64: "MOVD [$]11,", "MUL"
// loong64: "ALSLV [$]2,", "ALSLV [$]1,"
return x * 11
}
func m12(x int64) int64 {
// amd64: "LEAQ\t.*[*]2", "SHLQ\t[$]2,"
// arm64: "LSL\t[$]2,", "ADD\tR[0-9]+<<1,"
// loong64: "SLLV", "ALSLV\t[$]1,"
// amd64: "LEAQ .*[*]2", "SHLQ [$]2,"
// arm64: "LSL [$]2,", "ADD R[0-9]+<<1,"
// loong64: "SLLV", "ALSLV [$]1,"
return x * 12
}
func m13(x int64) int64 {
// amd64: "LEAQ\t.*[*]2", "LEAQ\t.*[*]4"
// arm64: "MOVD\t[$]13,", "MUL"
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]2,"
// amd64: "LEAQ .*[*]2", "LEAQ .*[*]4"
// arm64: "MOVD [$]13,", "MUL"
// loong64: "ALSLV [$]1,", "ALSLV [$]2,"
return x * 13
}
func m14(x int64) int64 {
// amd64: "IMUL3Q\t[$]14,"
// arm64: "LSL\t[$]4,", "SUB\tR[0-9]+<<1,"
// loong64: "ADDVU", "ALSLV\t[$]1", "ALSLV\t[$]2"
// amd64: "IMUL3Q [$]14,"
// arm64: "LSL [$]4,", "SUB R[0-9]+<<1,"
// loong64: "ADDVU", "ALSLV [$]1", "ALSLV [$]2"
return x * 14
}
func m15(x int64) int64 {
// amd64: "LEAQ\t.*[*]2", "LEAQ\t.*[*]4"
// arm64: "LSL\t[$]4,", "SUB\tR[0-9]+,"
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]2,"
// amd64: "LEAQ .*[*]2", "LEAQ .*[*]4"
// arm64: "LSL [$]4,", "SUB R[0-9]+,"
// loong64: "ALSLV [$]1,", "ALSLV [$]2,"
return x * 15
}
func m16(x int64) int64 {
// amd64: "SHLQ\t[$]4,"
// arm64: "LSL\t[$]4,"
// loong64: "SLLV\t[$]4,"
// amd64: "SHLQ [$]4,"
// arm64: "LSL [$]4,"
// loong64: "SLLV [$]4,"
return x * 16
}
func m17(x int64) int64 {
// amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]8"
// arm64: "ADD\tR[0-9]+<<4,"
// loong64: "ALSLV\t[$]"
// amd64: "LEAQ .*[*]1", "LEAQ .*[*]8"
// arm64: "ADD R[0-9]+<<4,"
// loong64: "ALSLV [$]"
return x * 17
}
func m18(x int64) int64 {
// amd64: "LEAQ\t.*[*]1", "LEAQ\t.*[*]8"
// arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<3,"
// loong64: "ADDVU", "ALSLV\t[$]3,"
// amd64: "LEAQ .*[*]1", "LEAQ .*[*]8"
// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<3,"
// loong64: "ADDVU", "ALSLV [$]3,"
return x * 18
}
func m19(x int64) int64 {
// amd64: "LEAQ\t.*[*]8", "LEAQ\t.*[*]2"
// arm64: "MOVD\t[$]19,", "MUL"
// loong64: "ALSLV\t[$]3,", "ALSLV\t[$]1,"
// amd64: "LEAQ .*[*]8", "LEAQ .*[*]2"
// arm64: "MOVD [$]19,", "MUL"
// loong64: "ALSLV [$]3,", "ALSLV [$]1,"
return x * 19
}
func m20(x int64) int64 {
// amd64: "LEAQ\t.*[*]4", "SHLQ\t[$]2,"
// arm64: "LSL\t[$]2,", "ADD\tR[0-9]+<<2,"
// loong64: "SLLV\t[$]2,", "ALSLV\t[$]2,"
// amd64: "LEAQ .*[*]4", "SHLQ [$]2,"
// arm64: "LSL [$]2,", "ADD R[0-9]+<<2,"
// loong64: "SLLV [$]2,", "ALSLV [$]2,"
return x * 20
}
func m21(x int64) int64 {
// amd64: "LEAQ\t.*[*]4", "LEAQ\t.*[*]4"
// arm64: "MOVD\t[$]21,", "MUL"
// loong64: "ALSLV\t[$]2,", "ALSLV\t[$]2,"
// amd64: "LEAQ .*[*]4", "LEAQ .*[*]4"
// arm64: "MOVD [$]21,", "MUL"
// loong64: "ALSLV [$]2,", "ALSLV [$]2,"
return x * 21
}
func m22(x int64) int64 {
// amd64: "IMUL3Q\t[$]22,"
// arm64: "MOVD\t[$]22,", "MUL"
// loong64: "ADDVU", "ALSLV\t[$]2,", "ALSLV\t[$]2,"
// amd64: "IMUL3Q [$]22,"
// arm64: "MOVD [$]22,", "MUL"
// loong64: "ADDVU", "ALSLV [$]2,", "ALSLV [$]2,"
return x * 22
}
func m23(x int64) int64 {
// amd64: "IMUL3Q\t[$]23,"
// arm64: "MOVD\t[$]23,", "MUL"
// loong64: "ALSLV\t[$]1,", "SUBVU", "ALSLV\t[$]3,"
// amd64: "IMUL3Q [$]23,"
// arm64: "MOVD [$]23,", "MUL"
// loong64: "ALSLV [$]1,", "SUBVU", "ALSLV [$]3,"
return x * 23
}
func m24(x int64) int64 {
// amd64: "LEAQ\t.*[*]2", "SHLQ\t[$]3,"
// arm64: "LSL\t[$]3,", "ADD\tR[0-9]+<<1,"
// loong64: "SLLV\t[$]3", "ALSLV\t[$]1,"
// amd64: "LEAQ .*[*]2", "SHLQ [$]3,"
// arm64: "LSL [$]3,", "ADD R[0-9]+<<1,"
// loong64: "SLLV [$]3", "ALSLV [$]1,"
return x * 24
}
func m25(x int64) int64 {
// amd64: "LEAQ\t.*[*]4", "LEAQ\t.*[*]4"
// arm64: "MOVD\t[$]25,", "MUL"
// loong64: "ALSLV\t[$]2,", "ALSLV\t[$]2,"
// amd64: "LEAQ .*[*]4", "LEAQ .*[*]4"
// arm64: "MOVD [$]25,", "MUL"
// loong64: "ALSLV [$]2,", "ALSLV [$]2,"
return x * 25
}
func m26(x int64) int64 {
// amd64: "IMUL3Q\t[$]26,"
// arm64: "MOVD\t[$]26,", "MUL"
// loong64: "ADDVU", "ALSLV\t[$]1,", "ALSLV\t[$]3,"
// amd64: "IMUL3Q [$]26,"
// arm64: "MOVD [$]26,", "MUL"
// loong64: "ADDVU", "ALSLV [$]1,", "ALSLV [$]3,"
return x * 26
}
func m27(x int64) int64 {
// amd64: "LEAQ\t.*[*]2", "LEAQ\t.*[*]8"
// arm64: "MOVD\t[$]27,", "MUL"
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]3,"
// amd64: "LEAQ .*[*]2", "LEAQ .*[*]8"
// arm64: "MOVD [$]27,", "MUL"
// loong64: "ALSLV [$]1,", "ALSLV [$]3,"
return x * 27
}
func m28(x int64) int64 {
// amd64: "IMUL3Q\t[$]28,"
// arm64: "LSL\t[$]5, "SUB\tR[0-9]+<<2,"
// loong64: "ALSLV\t[$]1,","SLLV\t[$]2,","ALSLV\t[$]3,"
// amd64: "IMUL3Q [$]28,"
// arm64: "LSL [$]5, "SUB R[0-9]+<<2,"
// loong64: "ALSLV [$]1," "SLLV [$]2," "ALSLV [$]3,"
return x * 28
}
func m29(x int64) int64 {
// amd64: "IMUL3Q\t[$]29,"
// arm64: "MOVD\t[$]29,", "MUL"
// loong64: "ALSLV\t[$]1,","SLLV\t[$]5,","SUBVU"
// amd64: "IMUL3Q [$]29,"
// arm64: "MOVD [$]29,", "MUL"
// loong64: "ALSLV [$]1," "SLLV [$]5," "SUBVU"
return x * 29
}
func m30(x int64) int64 {
// amd64: "IMUL3Q\t[$]30,"
// arm64: "LSL\t[$]5,", "SUB\tR[0-9]+<<1,"
// loong64: "ADDVU","SLLV\t[$]5,","SUBVU"
// amd64: "IMUL3Q [$]30,"
// arm64: "LSL [$]5,", "SUB R[0-9]+<<1,"
// loong64: "ADDVU" "SLLV [$]5," "SUBVU"
return x * 30
}
func m31(x int64) int64 {
// amd64: "SHLQ\t[$]5,", "SUBQ"
// arm64: "LSL\t[$]5,", "SUB\tR[0-9]+,"
// loong64: "SLLV\t[$]5,","SUBVU"
// amd64: "SHLQ [$]5,", "SUBQ"
// arm64: "LSL [$]5,", "SUB R[0-9]+,"
// loong64: "SLLV [$]5," "SUBVU"
return x * 31
}
func m32(x int64) int64 {
// amd64: "SHLQ\t[$]5,"
// arm64: "LSL\t[$]5,"
// loong64: "SLLV\t[$]5,"
// amd64: "SHLQ [$]5,"
// arm64: "LSL [$]5,"
// loong64: "SLLV [$]5,"
return x * 32
}
func m33(x int64) int64 {
// amd64: "SHLQ\t[$]2,", "LEAQ\t.*[*]8"
// arm64: "ADD\tR[0-9]+<<5,"
// loong64: "ADDVU", "ALSLV\t[$]4,"
// amd64: "SHLQ [$]2,", "LEAQ .*[*]8"
// arm64: "ADD R[0-9]+<<5,"
// loong64: "ADDVU", "ALSLV [$]4,"
return x * 33
}
func m34(x int64) int64 {
// amd64: "SHLQ\t[$]5,", "LEAQ\t.*[*]2"
// arm64: "ADD\tR[0-9]+,", "ADD\tR[0-9]+<<4,"
// loong64: "ADDVU", "ALSLV\t[$]4,"
// amd64: "SHLQ [$]5,", "LEAQ .*[*]2"
// arm64: "ADD R[0-9]+,", "ADD R[0-9]+<<4,"
// loong64: "ADDVU", "ALSLV [$]4,"
return x * 34
}
func m35(x int64) int64 {
// amd64: "IMUL3Q\t[$]35,"
// arm64: "MOVD\t[$]35,", "MUL"
// loong64: "ALSLV\t[$]4,", "ALSLV\t[$]1,"
// amd64: "IMUL3Q [$]35,"
// arm64: "MOVD [$]35,", "MUL"
// loong64: "ALSLV [$]4,", "ALSLV [$]1,"
return x * 35
}
func m36(x int64) int64 {
// amd64: "LEAQ\t.*[*]8", "SHLQ\t[$]2,"
// arm64: "LSL\t[$]2,", "ADD\tR[0-9]+<<3,"
// loong64: "SLLV\t[$]2,", "ALSLV\t[$]3,"
// amd64: "LEAQ .*[*]8", "SHLQ [$]2,"
// arm64: "LSL [$]2,", "ADD R[0-9]+<<3,"
// loong64: "SLLV [$]2,", "ALSLV [$]3,"
return x * 36
}
func m37(x int64) int64 {
// amd64: "LEAQ\t.*[*]8", "LEAQ\t.*[*]4"
// arm64: "MOVD\t[$]37,", "MUL"
// loong64: "ALSLV\t[$]3,", "ALSLV\t[$]2,"
// amd64: "LEAQ .*[*]8", "LEAQ .*[*]4"
// arm64: "MOVD [$]37,", "MUL"
// loong64: "ALSLV [$]3,", "ALSLV [$]2,"
return x * 37
}
func m38(x int64) int64 {
// amd64: "IMUL3Q\t[$]38,"
// arm64: "MOVD\t[$]38,", "MUL"
// loong64: "ALSLV\t[$]3,", "ALSLV\t[$]2,"
// amd64: "IMUL3Q [$]38,"
// arm64: "MOVD [$]38,", "MUL"
// loong64: "ALSLV [$]3,", "ALSLV [$]2,"
return x * 38
}
func m39(x int64) int64 {
// amd64: "IMUL3Q\t[$]39,"
// arm64: "MOVD\t[$]39,", "MUL"
// loong64: "ALSLV\t[$]2,", "SUBVU", "ALSLV\t[$]3,"
// amd64: "IMUL3Q [$]39,"
// arm64: "MOVD [$]39,", "MUL"
// loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]3,"
return x * 39
}
func m40(x int64) int64 {
// amd64: "LEAQ\t.*[*]4", "SHLQ\t[$]3,"
// arm64: "LSL\t[$]3,", "ADD\tR[0-9]+<<2,"
// loong64: "SLLV\t[$]3,", "ALSLV\t[$]2,"
// amd64: "LEAQ .*[*]4", "SHLQ [$]3,"
// arm64: "LSL [$]3,", "ADD R[0-9]+<<2,"
// loong64: "SLLV [$]3,", "ALSLV [$]2,"
return x * 40
}
func mn1(x int64) int64 {
// amd64: "NEGQ\t"
// arm64: "NEG\tR[0-9]+,"
// loong64: "SUBVU\tR[0-9], R0,"
// amd64: "NEGQ "
// arm64: "NEG R[0-9]+,"
// loong64: "SUBVU R[0-9], R0,"
return x * -1
}
func mn2(x int64) int64 {
// amd64: "NEGQ", "ADDQ"
// arm64: "NEG\tR[0-9]+<<1,"
// loong64: "ADDVU","SUBVU\tR[0-9], R0,"
// arm64: "NEG R[0-9]+<<1,"
// loong64: "ADDVU" "SUBVU R[0-9], R0,"
return x * -2
}
func mn3(x int64) int64 {
// amd64: "NEGQ", "LEAQ\t.*[*]2"
// arm64: "SUB\tR[0-9]+<<2,"
// loong64: "SUBVU", "ALSLV\t[$]1,"
// amd64: "NEGQ", "LEAQ .*[*]2"
// arm64: "SUB R[0-9]+<<2,"
// loong64: "SUBVU", "ALSLV [$]1,"
return x * -3
}
func mn4(x int64) int64 {
// amd64: "NEGQ", "SHLQ\t[$]2,"
// arm64: "NEG\tR[0-9]+<<2,"
// loong64: "SLLV\t[$]2,","SUBVU\tR[0-9], R0,"
// amd64: "NEGQ", "SHLQ [$]2,"
// arm64: "NEG R[0-9]+<<2,"
// loong64: "SLLV [$]2," "SUBVU R[0-9], R0,"
return x * -4
}
func mn5(x int64) int64 {
// amd64: "NEGQ", "LEAQ\t.*[*]4"
// arm64: "NEG\tR[0-9]+,", "ADD\tR[0-9]+<<2,"
// loong64: "SUBVU", "ALSLV\t[$]2,"
// amd64: "NEGQ", "LEAQ .*[*]4"
// arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<2,"
// loong64: "SUBVU", "ALSLV [$]2,"
return x * -5
}
func mn6(x int64) int64 {
// amd64: "IMUL3Q\t[$]-6,"
// arm64: "ADD\tR[0-9]+,", "SUB\tR[0-9]+<<2,"
// loong64: "ADDVU", "SUBVU", "ALSLV\t[$]3,"
// amd64: "IMUL3Q [$]-6,"
// arm64: "ADD R[0-9]+,", "SUB R[0-9]+<<2,"
// loong64: "ADDVU", "SUBVU", "ALSLV [$]3,"
return x * -6
}
func mn7(x int64) int64 {
// amd64: "NEGQ", "LEAQ\t.*[*]8"
// arm64: "SUB\tR[0-9]+<<3,"
// loong64: "SUBVU", "ALSLV\t[$]3,"
// amd64: "NEGQ", "LEAQ .*[*]8"
// arm64: "SUB R[0-9]+<<3,"
// loong64: "SUBVU", "ALSLV [$]3,"
return x * -7
}
func mn8(x int64) int64 {
// amd64: "NEGQ", "SHLQ\t[$]3,"
// arm64: "NEG\tR[0-9]+<<3,"
// loong64: "SLLV\t[$]3","SUBVU\tR[0-9], R0,"
// amd64: "NEGQ", "SHLQ [$]3,"
// arm64: "NEG R[0-9]+<<3,"
// loong64: "SLLV [$]3" "SUBVU R[0-9], R0,"
return x * -8
}
func mn9(x int64) int64 {
// amd64: "NEGQ", "LEAQ\t.*[*]8"
// arm64: "NEG\tR[0-9]+,", "ADD\tR[0-9]+<<3,"
// loong64: "SUBVU", "ALSLV\t[$]3,"
// amd64: "NEGQ", "LEAQ .*[*]8"
// arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<3,"
// loong64: "SUBVU", "ALSLV [$]3,"
return x * -9
}
func mn10(x int64) int64 {
// amd64: "IMUL3Q\t[$]-10,"
// arm64: "MOVD\t[$]-10,", "MUL"
// loong64: "ADDVU", "ALSLV\t[$]3", "SUBVU"
// amd64: "IMUL3Q [$]-10,"
// arm64: "MOVD [$]-10,", "MUL"
// loong64: "ADDVU", "ALSLV [$]3", "SUBVU"
return x * -10
}
func mn11(x int64) int64 {
// amd64: "IMUL3Q\t[$]-11,"
// arm64: "MOVD\t[$]-11,", "MUL"
// loong64: "ALSLV\t[$]2,", "SUBVU", "ALSLV\t[$]4,"
// amd64: "IMUL3Q [$]-11,"
// arm64: "MOVD [$]-11,", "MUL"
// loong64: "ALSLV [$]2,", "SUBVU", "ALSLV [$]4,"
return x * -11
}
func mn12(x int64) int64 {
// amd64: "IMUL3Q\t[$]-12,"
// arm64: "LSL\t[$]2,", "SUB\tR[0-9]+<<2,"
// loong64: "SUBVU", "SLLV\t[$]2,", "ALSLV\t[$]4,"
// amd64: "IMUL3Q [$]-12,"
// arm64: "LSL [$]2,", "SUB R[0-9]+<<2,"
// loong64: "SUBVU", "SLLV [$]2,", "ALSLV [$]4,"
return x * -12
}
func mn13(x int64) int64 {
// amd64: "IMUL3Q\t[$]-13,"
// arm64: "MOVD\t[$]-13,", "MUL"
// loong64: "ALSLV\t[$]4,", "SLLV\t[$]2, ", "SUBVU"
// amd64: "IMUL3Q [$]-13,"
// arm64: "MOVD [$]-13,", "MUL"
// loong64: "ALSLV [$]4,", "SLLV [$]2, ", "SUBVU"
return x * -13
}
func mn14(x int64) int64 {
// amd64: "IMUL3Q\t[$]-14,"
// arm64: "ADD\tR[0-9]+,", "SUB\tR[0-9]+<<3,"
// loong64: "ADDVU", "SUBVU", "ALSLV\t[$]4,"
// amd64: "IMUL3Q [$]-14,"
// arm64: "ADD R[0-9]+,", "SUB R[0-9]+<<3,"
// loong64: "ADDVU", "SUBVU", "ALSLV [$]4,"
return x * -14
}
func mn15(x int64) int64 {
// amd64: "SHLQ\t[$]4,", "SUBQ"
// arm64: "SUB\tR[0-9]+<<4,"
// loong64: "SUBVU", "ALSLV\t[$]4,"
// amd64: "SHLQ [$]4,", "SUBQ"
// arm64: "SUB R[0-9]+<<4,"
// loong64: "SUBVU", "ALSLV [$]4,"
return x * -15
}
func mn16(x int64) int64 {
// amd64: "NEGQ", "SHLQ\t[$]4,"
// arm64: "NEG\tR[0-9]+<<4,"
// loong64: "SLLV\t[$]4,","SUBVU\tR[0-9], R0,"
// amd64: "NEGQ", "SHLQ [$]4,"
// arm64: "NEG R[0-9]+<<4,"
// loong64: "SLLV [$]4," "SUBVU R[0-9], R0,"
return x * -16
}
func mn17(x int64) int64 {
// amd64: "IMUL3Q\t[$]-17,"
// arm64: "NEG\tR[0-9]+,", "ADD\tR[0-9]+<<4,"
// loong64: "SUBVU", "ALSLV\t[$]4,"
// amd64: "IMUL3Q [$]-17,"
// arm64: "NEG R[0-9]+,", "ADD R[0-9]+<<4,"
// loong64: "SUBVU", "ALSLV [$]4,"
return x * -17
}
func mn18(x int64) int64 {
// amd64: "IMUL3Q\t[$]-18,"
// arm64: "MOVD\t[$]-18,", "MUL"
// loong64: "ADDVU", "ALSLV\t[$]4,", "SUBVU"
// amd64: "IMUL3Q [$]-18,"
// arm64: "MOVD [$]-18,", "MUL"
// loong64: "ADDVU", "ALSLV [$]4,", "SUBVU"
return x * -18
}
func mn19(x int64) int64 {
// amd64: "IMUL3Q\t[$]-19,"
// arm64: "MOVD\t[$]-19,", "MUL"
// loong64: "ALSLV\t[$]1,", "ALSLV\t[$]4,", "SUBVU"
// amd64: "IMUL3Q [$]-19,"
// arm64: "MOVD [$]-19,", "MUL"
// loong64: "ALSLV [$]1,", "ALSLV [$]4,", "SUBVU"
return x * -19
}
func mn20(x int64) int64 {
// amd64: "IMUL3Q\t[$]-20,"
// arm64: "MOVD\t[$]-20,", "MUL"
// loong64: "SLLV\t[$]2,", "ALSLV\t[$]4,", "SUBVU"
// amd64: "IMUL3Q [$]-20,"
// arm64: "MOVD [$]-20,", "MUL"
// loong64: "SLLV [$]2,", "ALSLV [$]4,", "SUBVU"
return x * -20
}

82
test/codegen/noextend.go
View file

@ -26,7 +26,7 @@ var val8 [8]uint8
func set16(x8 int8, u8 *uint8, y8 int8, z8 uint8) {
// Truncate not needed, load does sign/zero extend
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
val16[0] = uint16(*u8)
// AND not needed due to size
@ -39,20 +39,20 @@ func set16(x8 int8, u8 *uint8, y8 int8, z8 uint8) {
}
func shiftidx(u8 *uint8, x16 *int16, u16 *uint16) {
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
val16[0] = uint16(sval16[*u8>>2])
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
sval16[1] = int16(val16[*x16>>1])
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
val16[1] = uint16(sval16[*u16>>2])
}
func setnox(x8 int8, u8 *uint8, y8 *int8, z8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) {
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
val16[0] = uint16(*u8)
// AND not needed due to size
@ -62,65 +62,65 @@ func setnox(x8 int8, u8 *uint8, y8 *int8, z8 *uint8, x16 *int16, u16 *uint16, x3
// ppc64x:-"ANDCC"
val16[1] = 255 & uint16(*u8+*z8)
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
sval32[1] = int32(*x16)
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
val32[0] = uint32(*u8)
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
val32[1] = uint32(*u16)
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
sval64[1] = int64(*x16)
// ppc64x:-"MOVW\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVW R\\d+,\\sR\\d+"
sval64[2] = int64(*x32)
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
val64[0] = uint64(*u8)
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
val64[1] = uint64(*u16)
// ppc64x:-"MOVWZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVWZ R\\d+,\\sR\\d+"
val64[2] = uint64(*u32)
}
func cmp16(u8 *uint8, x32 *int32, u32 *uint32, x64 *int64, u64 *uint64) bool {
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
if uint16(*u8) == val16[0] {
return true
}
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
if uint16(*u32>>16) == val16[0] {
return true
}
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
if uint16(*u64>>48) == val16[0] {
return true
}
// Verify the truncates are using the correct sign.
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
if int16(*x32) == sval16[0] {
return true
}
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
if uint16(*u32) == val16[0] {
return true
}
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
if int16(*x64) == sval16[0] {
return true
}
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
if uint16(*u64) == val16[0] {
return true
}
@ -130,28 +130,28 @@ func cmp16(u8 *uint8, x32 *int32, u32 *uint32, x64 *int64, u64 *uint64) bool {
func cmp32(u8 *uint8, x16 *int16, u16 *uint16, x64 *int64, u64 *uint64) bool {
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
if uint32(*u8) == val32[0] {
return true
}
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
if int32(*x16) == sval32[0] {
return true
}
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
if uint32(*u16) == val32[0] {
return true
}
// Verify the truncates are using the correct sign.
// ppc64x:-"MOVWZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVWZ R\\d+,\\sR\\d+"
if int32(*x64) == sval32[0] {
return true
}
// ppc64x:-"MOVW\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVW R\\d+,\\sR\\d+"
if uint32(*u64) == val32[0] {
return true
}
@ -161,27 +161,27 @@ func cmp32(u8 *uint8, x16 *int16, u16 *uint16, x64 *int64, u64 *uint64) bool {
func cmp64(u8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) bool {
// ppc64x:-"MOVBZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVBZ R\\d+,\\sR\\d+"
if uint64(*u8) == val64[0] {
return true
}
// ppc64x:-"MOVH\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVH R\\d+,\\sR\\d+"
if int64(*x16) == sval64[0] {
return true
}
// ppc64x:-"MOVHZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVHZ R\\d+,\\sR\\d+"
if uint64(*u16) == val64[0] {
return true
}
// ppc64x:-"MOVW\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVW R\\d+,\\sR\\d+"
if int64(*x32) == sval64[0] {
return true
}
// ppc64x:-"MOVWZ\tR\\d+,\\sR\\d+"
// ppc64x:-"MOVWZ R\\d+,\\sR\\d+"
if uint64(*u32) == val64[0] {
return true
}
@ -193,40 +193,40 @@ func cmp64(u8 *uint8, x16 *int16, u16 *uint16, x32 *int32, u32 *uint32) bool {
func noUnsignEXT(t1, t2, t3, t4 uint32, k int64) uint64 {
var ret uint64
// arm64:"RORW",-"MOVWU"
// arm64:"RORW" -"MOVWU"
ret += uint64(bits.RotateLeft32(t1, 7))
// arm64:"MULW",-"MOVWU"
// arm64:"MULW" -"MOVWU"
ret *= uint64(t1 * t2)
// arm64:"MNEGW",-"MOVWU"
// arm64:"MNEGW" -"MOVWU"
ret += uint64(-t1 * t3)
// arm64:"UDIVW",-"MOVWU"
// arm64:"UDIVW" -"MOVWU"
ret += uint64(t1 / t4)
// arm64:-"MOVWU"
ret += uint64(t2 % t3)
// arm64:"MSUBW",-"MOVWU"
// arm64:"MSUBW" -"MOVWU"
ret += uint64(t1 - t2*t3)
// arm64:"MADDW",-"MOVWU"
// arm64:"MADDW" -"MOVWU"
ret += uint64(t3*t4 + t2)
// arm64:"REVW",-"MOVWU"
// arm64:"REVW" -"MOVWU"
ret += uint64(bits.ReverseBytes32(t1))
// arm64:"RBITW",-"MOVWU"
// arm64:"RBITW" -"MOVWU"
ret += uint64(bits.Reverse32(t1))
// arm64:"CLZW",-"MOVWU"
// arm64:"CLZW" -"MOVWU"
ret += uint64(bits.LeadingZeros32(t1))
// arm64:"REV16W",-"MOVWU"
// arm64:"REV16W" -"MOVWU"
ret += uint64(((t1 & 0xff00ff00) >> 8) | ((t1 & 0x00ff00ff) << 8))
// arm64:"EXTRW",-"MOVWU"
// arm64:"EXTRW" -"MOVWU"
ret += uint64((t1 << 25) | (t2 >> 7))
return ret

8
test/codegen/reflect_type.go
View file

@ -9,13 +9,13 @@ package codegen
import "reflect"
func intPtrTypeSize() uintptr {
// amd64:"MOVL\t[$]8,",-"CALL"
// arm64:"MOVD\t[$]8,",-"CALL"
// amd64:"MOVL [$]8," -"CALL"
// arm64:"MOVD [$]8," -"CALL"
return reflect.TypeFor[*int]().Size()
}
func intPtrTypeKind() reflect.Kind {
// amd64:"MOVL\t[$]22,",-"CALL"
// arm64:"MOVD\t[$]22,",-"CALL"
// amd64:"MOVL [$]22," -"CALL"
// arm64:"MOVD [$]22," -"CALL"
return reflect.TypeFor[*int]().Kind()
}

4
test/codegen/regabi_regalloc.go
View file

@ -8,13 +8,13 @@ package codegen
//go:registerparams
func f1(a, b int) {
// amd64:"MOVQ\tBX, CX", "MOVQ\tAX, BX", "MOVL\t\\$1, AX", -"MOVQ\t.*DX"
// amd64:"MOVQ BX, CX", "MOVQ AX, BX", "MOVL [$]1, AX", -"MOVQ .*DX"
g(1, a, b)
}
//go:registerparams
func f2(a, b int) {
// amd64:"MOVQ\tBX, AX", "MOVQ\t[AB]X, CX", -"MOVQ\t.*, BX"
// amd64:"MOVQ BX, AX", "MOVQ [AB]X, CX", -"MOVQ .*, BX"
g(b, b, b)
}

4
test/codegen/retpoline.go
View file

@ -5,12 +5,12 @@
package codegen
func CallFunc(f func()) {
// amd64:`CALL\truntime.retpoline`
// amd64:`CALL runtime.retpoline`
f()
}
func CallInterface(x interface{ M() }) {
// amd64:`CALL\truntime.retpoline`
// amd64:`CALL runtime.retpoline`
x.M()
}

214
test/codegen/rotate.go
View file

@ -15,36 +15,36 @@ import "math/bits"
func rot64(x uint64) uint64 {
var a uint64
// amd64:"ROLQ\t[$]7"
// ppc64x:"ROTL\t[$]7"
// loong64: "ROTRV\t[$]57"
// riscv64: "RORI\t[$]57"
// amd64:"ROLQ [$]7"
// ppc64x:"ROTL [$]7"
// loong64: "ROTRV [$]57"
// riscv64: "RORI [$]57"
a += x<<7 | x>>57
// amd64:"ROLQ\t[$]8"
// arm64:"ROR\t[$]56"
// s390x:"RISBGZ\t[$]0, [$]63, [$]8, "
// ppc64x:"ROTL\t[$]8"
// loong64: "ROTRV\t[$]56"
// riscv64: "RORI\t[$]56"
// amd64:"ROLQ [$]8"
// arm64:"ROR [$]56"
// s390x:"RISBGZ [$]0, [$]63, [$]8, "
// ppc64x:"ROTL [$]8"
// loong64: "ROTRV [$]56"
// riscv64: "RORI [$]56"
a += x<<8 + x>>56
// amd64:"ROLQ\t[$]9"
// arm64:"ROR\t[$]55"
// s390x:"RISBGZ\t[$]0, [$]63, [$]9, "
// ppc64x:"ROTL\t[$]9"
// loong64: "ROTRV\t[$]55"
// riscv64: "RORI\t[$]55"
// amd64:"ROLQ [$]9"
// arm64:"ROR [$]55"
// s390x:"RISBGZ [$]0, [$]63, [$]9, "
// ppc64x:"ROTL [$]9"
// loong64: "ROTRV [$]55"
// riscv64: "RORI [$]55"
a += x<<9 ^ x>>55
// amd64:"ROLQ\t[$]10"
// arm64:"ROR\t[$]54"
// s390x:"RISBGZ\t[$]0, [$]63, [$]10, "
// ppc64x:"ROTL\t[$]10"
// arm64:"ROR\t[$]54"
// s390x:"RISBGZ\t[$]0, [$]63, [$]10, "
// loong64: "ROTRV\t[$]54"
// riscv64: "RORI\t[$]54"
// amd64:"ROLQ [$]10"
// arm64:"ROR [$]54"
// s390x:"RISBGZ [$]0, [$]63, [$]10, "
// ppc64x:"ROTL [$]10"
// arm64:"ROR [$]54"
// s390x:"RISBGZ [$]0, [$]63, [$]10, "
// loong64: "ROTRV [$]54"
// riscv64: "RORI [$]54"
a += bits.RotateLeft64(x, 10)
return a
@ -53,40 +53,40 @@ func rot64(x uint64) uint64 {
func rot32(x uint32) uint32 {
var a uint32
// amd64:"ROLL\t[$]7"
// arm:"MOVW\tR\\d+@>25"
// ppc64x:"ROTLW\t[$]7"
// loong64: "ROTR\t[$]25"
// riscv64: "RORIW\t[$]25"
// amd64:"ROLL [$]7"
// arm:"MOVW R\\d+@>25"
// ppc64x:"ROTLW [$]7"
// loong64: "ROTR [$]25"
// riscv64: "RORIW [$]25"
a += x<<7 | x>>25
// amd64:`ROLL\t[$]8`
// arm:"MOVW\tR\\d+@>24"
// arm64:"RORW\t[$]24"
// s390x:"RLL\t[$]8"
// ppc64x:"ROTLW\t[$]8"
// loong64: "ROTR\t[$]24"
// riscv64: "RORIW\t[$]24"
// amd64:`ROLL [$]8`
// arm:"MOVW R\\d+@>24"
// arm64:"RORW [$]24"
// s390x:"RLL [$]8"
// ppc64x:"ROTLW [$]8"
// loong64: "ROTR [$]24"
// riscv64: "RORIW [$]24"
a += x<<8 + x>>24
// amd64:"ROLL\t[$]9"
// arm:"MOVW\tR\\d+@>23"
// arm64:"RORW\t[$]23"
// s390x:"RLL\t[$]9"
// ppc64x:"ROTLW\t[$]9"
// loong64: "ROTR\t[$]23"
// riscv64: "RORIW\t[$]23"
// amd64:"ROLL [$]9"
// arm:"MOVW R\\d+@>23"
// arm64:"RORW [$]23"
// s390x:"RLL [$]9"
// ppc64x:"ROTLW [$]9"
// loong64: "ROTR [$]23"
// riscv64: "RORIW [$]23"
a += x<<9 ^ x>>23
// amd64:"ROLL\t[$]10"
// arm:"MOVW\tR\\d+@>22"
// arm64:"RORW\t[$]22"
// s390x:"RLL\t[$]10"
// ppc64x:"ROTLW\t[$]10"
// arm64:"RORW\t[$]22"
// s390x:"RLL\t[$]10"
// loong64: "ROTR\t[$]22"
// riscv64: "RORIW\t[$]22"
// amd64:"ROLL [$]10"
// arm:"MOVW R\\d+@>22"
// arm64:"RORW [$]22"
// s390x:"RLL [$]10"
// ppc64x:"ROTLW [$]10"
// arm64:"RORW [$]22"
// s390x:"RLL [$]10"
// loong64: "ROTR [$]22"
// riscv64: "RORIW [$]22"
a += bits.RotateLeft32(x, 10)
return a
@ -95,16 +95,16 @@ func rot32(x uint32) uint32 {
func rot16(x uint16) uint16 {
var a uint16
// amd64:"ROLW\t[$]7"
// riscv64: "OR","SLLI","SRLI",-"AND"
// amd64:"ROLW [$]7"
// riscv64: "OR" "SLLI" "SRLI" -"AND"
a += x<<7 | x>>9
// amd64:`ROLW\t[$]8`
// riscv64: "OR","SLLI","SRLI",-"AND"
// amd64:`ROLW [$]8`
// riscv64: "OR" "SLLI" "SRLI" -"AND"
a += x<<8 + x>>8
// amd64:"ROLW\t[$]9"
// riscv64: "OR","SLLI","SRLI",-"AND"
// amd64:"ROLW [$]9"
// riscv64: "OR" "SLLI" "SRLI" -"AND"
a += x<<9 ^ x>>7
return a
@ -113,16 +113,16 @@ func rot16(x uint16) uint16 {
func rot8(x uint8) uint8 {
var a uint8
// amd64:"ROLB\t[$]5"
// riscv64: "OR","SLLI","SRLI",-"AND"
// amd64:"ROLB [$]5"
// riscv64: "OR" "SLLI" "SRLI" -"AND"
a += x<<5 | x>>3
// amd64:`ROLB\t[$]6`
// riscv64: "OR","SLLI","SRLI",-"AND"
// amd64:`ROLB [$]6`
// riscv64: "OR" "SLLI" "SRLI" -"AND"
a += x<<6 + x>>2
// amd64:"ROLB\t[$]7"
// riscv64: "OR","SLLI","SRLI",-"AND"
// amd64:"ROLB [$]7"
// riscv64: "OR" "SLLI" "SRLI" -"AND"
a += x<<7 ^ x>>1
return a
@ -137,18 +137,18 @@ func rot64nc(x uint64, z uint) uint64 {
z &= 63
// amd64:"ROLQ",-"AND"
// arm64:"ROR","NEG",-"AND"
// ppc64x:"ROTL",-"NEG",-"AND"
// amd64:"ROLQ" -"AND"
// arm64:"ROR" "NEG" -"AND"
// ppc64x:"ROTL" -"NEG" -"AND"
// loong64: "ROTRV", -"AND"
// riscv64: "ROL",-"AND"
// riscv64: "ROL" -"AND"
a += x<<z | x>>(64-z)
// amd64:"RORQ",-"AND"
// arm64:"ROR",-"NEG",-"AND"
// ppc64x:"ROTL","NEG",-"AND"
// amd64:"RORQ" -"AND"
// arm64:"ROR" -"NEG" -"AND"
// ppc64x:"ROTL" "NEG" -"AND"
// loong64: "ROTRV", -"AND"
// riscv64: "ROR",-"AND"
// riscv64: "ROR" -"AND"
a += x>>z | x<<(64-z)
return a
@ -159,18 +159,18 @@ func rot32nc(x uint32, z uint) uint32 {
z &= 31
// amd64:"ROLL",-"AND"
// arm64:"ROR","NEG",-"AND"
// ppc64x:"ROTLW",-"NEG",-"AND"
// amd64:"ROLL" -"AND"
// arm64:"ROR" "NEG" -"AND"
// ppc64x:"ROTLW" -"NEG" -"AND"
// loong64: "ROTR", -"AND"
// riscv64: "ROLW",-"AND"
// riscv64: "ROLW" -"AND"
a += x<<z | x>>(32-z)
// amd64:"RORL",-"AND"
// arm64:"ROR",-"NEG",-"AND"
// ppc64x:"ROTLW","NEG",-"AND"
// amd64:"RORL" -"AND"
// arm64:"ROR" -"NEG" -"AND"
// ppc64x:"ROTLW" "NEG" -"AND"
// loong64: "ROTR", -"AND"
// riscv64: "RORW",-"AND"
// riscv64: "RORW" -"AND"
a += x>>z | x<<(32-z)
return a
@ -181,12 +181,12 @@ func rot16nc(x uint16, z uint) uint16 {
z &= 15
// amd64:"ROLW",-"ANDQ"
// riscv64: "OR","SLL","SRL",-"AND\t"
// amd64:"ROLW" -"ANDQ"
// riscv64: "OR" "SLL" "SRL" -"AND "
a += x<<z | x>>(16-z)
// amd64:"RORW",-"ANDQ"
// riscv64: "OR","SLL","SRL",-"AND\t"
// amd64:"RORW" -"ANDQ"
// riscv64: "OR" "SLL" "SRL" -"AND "
a += x>>z | x<<(16-z)
return a
@ -197,12 +197,12 @@ func rot8nc(x uint8, z uint) uint8 {
z &= 7
// amd64:"ROLB",-"ANDQ"
// riscv64: "OR","SLL","SRL",-"AND\t"
// amd64:"ROLB" -"ANDQ"
// riscv64: "OR" "SLL" "SRL" -"AND "
a += x<<z | x>>(8-z)
// amd64:"RORB",-"ANDQ"
// riscv64: "OR","SLL","SRL",-"AND\t"
// amd64:"RORB" -"ANDQ"
// riscv64: "OR" "SLL" "SRL" -"AND "
a += x>>z | x<<(8-z)
return a
@ -210,14 +210,14 @@ func rot8nc(x uint8, z uint) uint8 {
// Issue 18254: rotate after inlining
func f32(x uint32) uint32 {
// amd64:"ROLL\t[$]7"
// amd64:"ROLL [$]7"
return rot32nc(x, 7)
}
func doubleRotate(x uint64) uint64 {
x = (x << 5) | (x >> 59)
// amd64:"ROLQ\t[$]15"
// arm64:"ROR\t[$]49"
// amd64:"ROLQ [$]15"
// arm64:"ROR [$]49"
x = (x << 10) | (x >> 54)
return x
}
@ -229,51 +229,51 @@ func doubleRotate(x uint64) uint64 {
func checkMaskedRotate32(a []uint32, r int) {
i := 0
// ppc64x: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
// ppc64x: "RLWNM [$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
a[i] = bits.RotateLeft32(a[i], 16) & 0xFF0000
i++
// ppc64x: "RLWNM\t[$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
// ppc64x: "RLWNM [$]16, R[0-9]+, [$]8, [$]15, R[0-9]+"
a[i] = bits.RotateLeft32(a[i]&0xFF, 16)
i++
// ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]27, R[0-9]+"
// ppc64x: "RLWNM [$]4, R[0-9]+, [$]20, [$]27, R[0-9]+"
a[i] = bits.RotateLeft32(a[i], 4) & 0xFF0
i++
// ppc64x: "RLWNM\t[$]16, R[0-9]+, [$]24, [$]31, R[0-9]+"
// ppc64x: "RLWNM [$]16, R[0-9]+, [$]24, [$]31, R[0-9]+"
a[i] = bits.RotateLeft32(a[i]&0xFF0000, 16)
i++
// ppc64x: "RLWNM\tR[0-9]+, R[0-9]+, [$]8, [$]15, R[0-9]+"
// ppc64x: "RLWNM R[0-9]+, R[0-9]+, [$]8, [$]15, R[0-9]+"
a[i] = bits.RotateLeft32(a[i], r) & 0xFF0000
i++
// ppc64x: "RLWNM\tR[0-9]+, R[0-9]+, [$]16, [$]23, R[0-9]+"
// ppc64x: "RLWNM R[0-9]+, R[0-9]+, [$]16, [$]23, R[0-9]+"
a[i] = bits.RotateLeft32(a[i], r) & 0xFF00
i++
// ppc64x: "RLWNM\tR[0-9]+, R[0-9]+, [$]20, [$]11, R[0-9]+"
// ppc64x: "RLWNM R[0-9]+, R[0-9]+, [$]20, [$]11, R[0-9]+"
a[i] = bits.RotateLeft32(a[i], r) & 0xFFF00FFF
i++
// ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]20, [$]11, R[0-9]+"
// ppc64x: "RLWNM [$]4, R[0-9]+, [$]20, [$]11, R[0-9]+"
a[i] = bits.RotateLeft32(a[i], 4) & 0xFFF00FFF
i++
}
// combined arithmetic and rotate on arm64
func checkArithmeticWithRotate(a *[1000]uint64) {
// arm64: "AND\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
// arm64: "AND R[0-9]+@>51, R[0-9]+, R[0-9]+"
a[2] = a[1] & bits.RotateLeft64(a[0], 13)
// arm64: "ORR\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
// arm64: "ORR R[0-9]+@>51, R[0-9]+, R[0-9]+"
a[5] = a[4] | bits.RotateLeft64(a[3], 13)
// arm64: "EOR\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
// arm64: "EOR R[0-9]+@>51, R[0-9]+, R[0-9]+"
a[8] = a[7] ^ bits.RotateLeft64(a[6], 13)
// arm64: "MVN\tR[0-9]+@>51, R[0-9]+"
// arm64: "MVN R[0-9]+@>51, R[0-9]+"
a[10] = ^bits.RotateLeft64(a[9], 13)
// arm64: "BIC\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
// arm64: "BIC R[0-9]+@>51, R[0-9]+, R[0-9]+"
a[13] = a[12] &^ bits.RotateLeft64(a[11], 13)
// arm64: "EON\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
// arm64: "EON R[0-9]+@>51, R[0-9]+, R[0-9]+"
a[16] = a[15] ^ ^bits.RotateLeft64(a[14], 13)
// arm64: "ORN\tR[0-9]+@>51, R[0-9]+, R[0-9]+"
// arm64: "ORN R[0-9]+@>51, R[0-9]+, R[0-9]+"
a[19] = a[18] | ^bits.RotateLeft64(a[17], 13)
// arm64: "TST\tR[0-9]+@>51, R[0-9]+"
// arm64: "TST R[0-9]+@>51, R[0-9]+"
if a[18]&bits.RotateLeft64(a[19], 13) == 0 {
a[20] = 1
}

4
test/codegen/schedule.go
View file

@ -8,8 +8,8 @@ package codegen
func f(n int) int {
r := 0
// arm64:-"MOVD\t R"
// amd64:-"LEAQ","INCQ"
// arm64:-"MOVD R"
// amd64:-"LEAQ" "INCQ"
for i := range n {
r += i
}

2
test/codegen/select.go
View file

@ -10,7 +10,7 @@ func f() {
ch1 := make(chan int)
ch2 := make(chan int)
for {
// amd64:-`MOVQ\t[$]0, command-line-arguments..autotmp_3`
// amd64:-`MOVQ [$]0, command-line-arguments..autotmp_3`
select {
case <-ch1:
case <-ch2:

352
test/codegen/shift.go
View file

@ -13,57 +13,57 @@ package codegen
func lshConst64x64(v int64) int64 {
// loong64:"SLLV"
// ppc64x:"SLD"
// riscv64:"SLLI",-"AND",-"SLTIU"
// riscv64:"SLLI" -"AND" -"SLTIU"
return v << uint64(33)
}
func rshConst64Ux64(v uint64) uint64 {
// loong64:"SRLV"
// ppc64x:"SRD"
// riscv64:"SRLI\t",-"AND",-"SLTIU"
// riscv64:"SRLI " -"AND" -"SLTIU"
return v >> uint64(33)
}
func rshConst64Ux64Overflow32(v uint32) uint64 {
// loong64:"MOVV\tR0,",-"SRL\t"
// riscv64:"MOV\t\\$0,",-"SRL"
// loong64:"MOVV R0," -"SRL "
// riscv64:"MOV [$]0," -"SRL"
return uint64(v) >> 32
}
func rshConst64Ux64Overflow16(v uint16) uint64 {
// loong64:"MOVV\tR0,",-"SRLV"
// riscv64:"MOV\t\\$0,",-"SRL"
// loong64:"MOVV R0," -"SRLV"
// riscv64:"MOV [$]0," -"SRL"
return uint64(v) >> 16
}
func rshConst64Ux64Overflow8(v uint8) uint64 {
// loong64:"MOVV\tR0,",-"SRLV"
// riscv64:"MOV\t\\$0,",-"SRL"
// loong64:"MOVV R0," -"SRLV"
// riscv64:"MOV [$]0," -"SRL"
return uint64(v) >> 8
}
func rshConst64x64(v int64) int64 {
// loong64:"SRAV"
// ppc64x:"SRAD"
// riscv64:"SRAI\t",-"OR",-"SLTIU"
// riscv64:"SRAI " -"OR" -"SLTIU"
return v >> uint64(33)
}
func rshConst64x64Overflow32(v int32) int64 {
// loong64:"SRA\t\\$31"
// riscv64:"SRAIW",-"SLLI",-"SRAI\t"
// loong64:"SRA [$]31"
// riscv64:"SRAIW" -"SLLI" -"SRAI "
return int64(v) >> 32
}
func rshConst64x64Overflow16(v int16) int64 {
// loong64:"SLLV\t\\$48","SRAV\t\\$63"
// riscv64:"SLLI","SRAI",-"SRAIW"
// loong64:"SLLV [$]48" "SRAV [$]63"
// riscv64:"SLLI" "SRAI" -"SRAIW"
return int64(v) >> 16
}
func rshConst64x64Overflow8(v int8) int64 {
// loong64:"SLLV\t\\$56","SRAV\t\\$63"
// riscv64:"SLLI","SRAI",-"SRAIW"
// loong64:"SLLV [$]56" "SRAV [$]63"
// riscv64:"SLLI" "SRAI" -"SRAIW"
return int64(v) >> 8
}
@ -78,84 +78,84 @@ func lshConst64x1(v int64) int64 {
}
func lshConst32x64(v int32) int32 {
// loong64:"SLL\t"
// loong64:"SLL "
// ppc64x:"SLW"
// riscv64:"SLLI",-"AND",-"SLTIU", -"MOVW"
// riscv64:"SLLI" -"AND" -"SLTIU", -"MOVW"
return v << uint64(29)
}
func rshConst32Ux64(v uint32) uint32 {
// loong64:"SRL\t"
// loong64:"SRL "
// ppc64x:"SRW"
// riscv64:"SRLIW",-"AND",-"SLTIU", -"MOVW"
// riscv64:"SRLIW" -"AND" -"SLTIU", -"MOVW"
return v >> uint64(29)
}
func rshConst32x64(v int32) int32 {
// loong64:"SRA\t"
// loong64:"SRA "
// ppc64x:"SRAW"
// riscv64:"SRAIW",-"OR",-"SLTIU", -"MOVW"
// riscv64:"SRAIW" -"OR" -"SLTIU", -"MOVW"
return v >> uint64(29)
}
func lshConst64x32(v int64) int64 {
// loong64:"SLLV"
// ppc64x:"SLD"
// riscv64:"SLLI",-"AND",-"SLTIU"
// riscv64:"SLLI" -"AND" -"SLTIU"
return v << uint32(33)
}
func rshConst64Ux32(v uint64) uint64 {
// loong64:"SRLV"
// ppc64x:"SRD"
// riscv64:"SRLI\t",-"AND",-"SLTIU"
// riscv64:"SRLI " -"AND" -"SLTIU"
return v >> uint32(33)
}
func rshConst64x32(v int64) int64 {
// loong64:"SRAV"
// ppc64x:"SRAD"
// riscv64:"SRAI\t",-"OR",-"SLTIU"
// riscv64:"SRAI " -"OR" -"SLTIU"
return v >> uint32(33)
}
func lshConst32x1Add(x int32) int32 {
// amd64:"SHLL\t[$]2"
// loong64:"SLL\t[$]2"
// riscv64:"SLLI\t[$]2"
// amd64:"SHLL [$]2"
// loong64:"SLL [$]2"
// riscv64:"SLLI [$]2"
return (x + x) << 1
}
func lshConst64x1Add(x int64) int64 {
// amd64:"SHLQ\t[$]2"
// loong64:"SLLV\t[$]2"
// riscv64:"SLLI\t[$]2"
// amd64:"SHLQ [$]2"
// loong64:"SLLV [$]2"
// riscv64:"SLLI [$]2"
return (x + x) << 1
}
func lshConst32x2Add(x int32) int32 {
// amd64:"SHLL\t[$]3"
// loong64:"SLL\t[$]3"
// riscv64:"SLLI\t[$]3"
// amd64:"SHLL [$]3"
// loong64:"SLL [$]3"
// riscv64:"SLLI [$]3"
return (x + x) << 2
}
func lshConst64x2Add(x int64) int64 {
// amd64:"SHLQ\t[$]3"
// loong64:"SLLV\t[$]3"
// riscv64:"SLLI\t[$]3"
// amd64:"SHLQ [$]3"
// loong64:"SLLV [$]3"
// riscv64:"SLLI [$]3"
return (x + x) << 2
}
func lshConst32x31Add(x int32) int32 {
// loong64:-"SLL\t","MOVV\tR0"
// riscv64:-"SLLI","MOV\t[$]0"
// loong64:-"SLL " "MOVV R0"
// riscv64:-"SLLI" "MOV [$]0"
return (x + x) << 31
}
func lshConst64x63Add(x int64) int64 {
// loong64:-"SLLV","MOVV\tR0"
// riscv64:-"SLLI","MOV\t[$]0"
// loong64:-"SLLV" "MOVV R0"
// riscv64:-"SLLI" "MOV [$]0"
return (x + x) << 63
}
@ -164,121 +164,121 @@ func lshConst64x63Add(x int64) int64 {
// ------------------ //
func lshMask64x64(v int64, s uint64) int64 {
// arm64:"LSL",-"AND"
// loong64:"SLLV",-"AND"
// ppc64x:"RLDICL",-"ORN",-"ISEL"
// riscv64:"SLL",-"AND\t",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// arm64:"LSL" -"AND"
// loong64:"SLLV" -"AND"
// ppc64x:"RLDICL" -"ORN" -"ISEL"
// riscv64:"SLL" -"AND " -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v << (s & 63)
}
func rshMask64Ux64(v uint64, s uint64) uint64 {
// arm64:"LSR",-"AND",-"CSEL"
// loong64:"SRLV",-"AND"
// ppc64x:"RLDICL",-"ORN",-"ISEL"
// riscv64:"SRL\t",-"AND\t",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// arm64:"LSR" -"AND" -"CSEL"
// loong64:"SRLV" -"AND"
// ppc64x:"RLDICL" -"ORN" -"ISEL"
// riscv64:"SRL " -"AND " -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v >> (s & 63)
}
func rshMask64x64(v int64, s uint64) int64 {
// arm64:"ASR",-"AND",-"CSEL"
// loong64:"SRAV",-"AND"
// ppc64x:"RLDICL",-"ORN",-"ISEL"
// riscv64:"SRA\t",-"OR",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// arm64:"ASR" -"AND" -"CSEL"
// loong64:"SRAV" -"AND"
// ppc64x:"RLDICL" -"ORN" -"ISEL"
// riscv64:"SRA " -"OR" -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v >> (s & 63)
}
func lshMask32x64(v int32, s uint64) int32 {
// arm64:"LSL",-"AND"
// loong64:"SLL\t","AND","SGTU","MASKEQZ"
// ppc64x:"ISEL",-"ORN"
// riscv64:"SLL",-"AND\t",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// arm64:"LSL" -"AND"
// loong64:"SLL " "AND" "SGTU" "MASKEQZ"
// ppc64x:"ISEL" -"ORN"
// riscv64:"SLL" -"AND " -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v << (s & 63)
}
func lsh5Mask32x64(v int32, s uint64) int32 {
// loong64:"SLL\t",-"AND"
// loong64:"SLL " -"AND"
return v << (s & 31)
}
func rshMask32Ux64(v uint32, s uint64) uint32 {
// arm64:"LSR",-"AND"
// loong64:"SRL\t","AND","SGTU","MASKEQZ"
// ppc64x:"ISEL",-"ORN"
// riscv64:"SRLW","SLTIU","NEG","AND\t",-"SRL\t"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// arm64:"LSR" -"AND"
// loong64:"SRL " "AND" "SGTU" "MASKEQZ"
// ppc64x:"ISEL" -"ORN"
// riscv64:"SRLW" "SLTIU" "NEG" "AND " -"SRL "
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v >> (s & 63)
}
func rsh5Mask32Ux64(v uint32, s uint64) uint32 {
// loong64:"SRL\t",-"AND"
// riscv64:"SRLW",-"AND\t",-"SLTIU",-"SRL\t"
// loong64:"SRL " -"AND"
// riscv64:"SRLW" -"AND " -"SLTIU" -"SRL "
return v >> (s & 31)
}
func rshMask32x64(v int32, s uint64) int32 {
// arm64:"ASR",-"AND"
// loong64:"SRA\t","AND","SGTU","SUBVU","OR"
// ppc64x:"ISEL",-"ORN"
// riscv64:"SRAW","OR","SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// arm64:"ASR" -"AND"
// loong64:"SRA " "AND" "SGTU" "SUBVU" "OR"
// ppc64x:"ISEL" -"ORN"
// riscv64:"SRAW" "OR" "SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v >> (s & 63)
}
func rsh5Mask32x64(v int32, s uint64) int32 {
// loong64:"SRA\t",-"AND"
// riscv64:"SRAW",-"OR",-"SLTIU"
// loong64:"SRA " -"AND"
// riscv64:"SRAW" -"OR" -"SLTIU"
return v >> (s & 31)
}
func lshMask64x32(v int64, s uint32) int64 {
// arm64:"LSL",-"AND"
// loong64:"SLLV",-"AND"
// ppc64x:"RLDICL",-"ORN"
// riscv64:"SLL",-"AND\t",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// arm64:"LSL" -"AND"
// loong64:"SLLV" -"AND"
// ppc64x:"RLDICL" -"ORN"
// riscv64:"SLL" -"AND " -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v << (s & 63)
}
func rshMask64Ux32(v uint64, s uint32) uint64 {
// arm64:"LSR",-"AND",-"CSEL"
// loong64:"SRLV",-"AND"
// ppc64x:"RLDICL",-"ORN"
// riscv64:"SRL\t",-"AND\t",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// arm64:"LSR" -"AND" -"CSEL"
// loong64:"SRLV" -"AND"
// ppc64x:"RLDICL" -"ORN"
// riscv64:"SRL " -"AND " -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v >> (s & 63)
}
func rshMask64x32(v int64, s uint32) int64 {
// arm64:"ASR",-"AND",-"CSEL"
// loong64:"SRAV",-"AND"
// ppc64x:"RLDICL",-"ORN",-"ISEL"
// riscv64:"SRA\t",-"OR",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// arm64:"ASR" -"AND" -"CSEL"
// loong64:"SRAV" -"AND"
// ppc64x:"RLDICL" -"ORN" -"ISEL"
// riscv64:"SRA " -"OR" -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v >> (s & 63)
}
func lshMask64x32Ext(v int64, s int32) int64 {
// ppc64x:"RLDICL",-"ORN",-"ISEL"
// riscv64:"SLL",-"AND\t",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// ppc64x:"RLDICL" -"ORN" -"ISEL"
// riscv64:"SLL" -"AND " -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v << uint(s&63)
}
func rshMask64Ux32Ext(v uint64, s int32) uint64 {
// ppc64x:"RLDICL",-"ORN",-"ISEL"
// riscv64:"SRL\t",-"AND\t",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// ppc64x:"RLDICL" -"ORN" -"ISEL"
// riscv64:"SRL " -"AND " -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v >> uint(s&63)
}
func rshMask64x32Ext(v int64, s int32) int64 {
// ppc64x:"RLDICL",-"ORN",-"ISEL"
// riscv64:"SRA\t",-"OR",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// ppc64x:"RLDICL" -"ORN" -"ISEL"
// riscv64:"SRA " -"OR" -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
return v >> uint(s&63)
}
@ -316,10 +316,10 @@ func lshSignedMasked(v8 int8, v16 int16, v32 int32, v64 int64, x int) {
func lshGuarded64(v int64, s uint) int64 {
if s < 64 {
// riscv64:"SLL",-"AND",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// wasm:-"Select",-".*LtU"
// arm64:"LSL",-"CSEL"
// riscv64:"SLL" -"AND" -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
// wasm:-"Select" -".*LtU"
// arm64:"LSL" -"CSEL"
return v << s
}
panic("shift too large")
@ -327,10 +327,10 @@ func lshGuarded64(v int64, s uint) int64 {
func rshGuarded64U(v uint64, s uint) uint64 {
if s < 64 {
// riscv64:"SRL\t",-"AND",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// wasm:-"Select",-".*LtU"
// arm64:"LSR",-"CSEL"
// riscv64:"SRL " -"AND" -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
// wasm:-"Select" -".*LtU"
// arm64:"LSR" -"CSEL"
return v >> s
}
panic("shift too large")
@ -338,10 +338,10 @@ func rshGuarded64U(v uint64, s uint) uint64 {
func rshGuarded64(v int64, s uint) int64 {
if s < 64 {
// riscv64:"SRA\t",-"OR",-"SLTIU"
// s390x:-"RISBGZ",-"AND",-"LOCGR"
// wasm:-"Select",-".*LtU"
// arm64:"ASR",-"CSEL"
// riscv64:"SRA " -"OR" -"SLTIU"
// s390x:-"RISBGZ" -"AND" -"LOCGR"
// wasm:-"Select" -".*LtU"
// arm64:"ASR" -"CSEL"
return v >> s
}
panic("shift too large")
@ -349,19 +349,19 @@ func rshGuarded64(v int64, s uint) int64 {
func provedUnsignedShiftLeft(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) {
if shift >= 0 && shift < 64 {
// arm64:"LSL",-"CSEL"
// arm64:"LSL" -"CSEL"
r1 = val64 << shift
}
if shift >= 0 && shift < 32 {
// arm64:"LSL",-"CSEL"
// arm64:"LSL" -"CSEL"
r2 = val32 << shift
}
if shift >= 0 && shift < 16 {
// arm64:"LSL",-"CSEL"
// arm64:"LSL" -"CSEL"
r3 = val16 << shift
}
if shift >= 0 && shift < 8 {
// arm64:"LSL",-"CSEL"
// arm64:"LSL" -"CSEL"
r4 = val8 << shift
}
return r1, r2, r3, r4
@ -369,19 +369,19 @@ func provedUnsignedShiftLeft(val64 uint64, val32 uint32, val16 uint16, val8 uint
func provedSignedShiftLeft(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) {
if shift >= 0 && shift < 64 {
// arm64:"LSL",-"CSEL"
// arm64:"LSL" -"CSEL"
r1 = val64 << shift
}
if shift >= 0 && shift < 32 {
// arm64:"LSL",-"CSEL"
// arm64:"LSL" -"CSEL"
r2 = val32 << shift
}
if shift >= 0 && shift < 16 {
// arm64:"LSL",-"CSEL"
// arm64:"LSL" -"CSEL"
r3 = val16 << shift
}
if shift >= 0 && shift < 8 {
// arm64:"LSL",-"CSEL"
// arm64:"LSL" -"CSEL"
r4 = val8 << shift
}
return r1, r2, r3, r4
@ -389,19 +389,19 @@ func provedSignedShiftLeft(val64 int64, val32 int32, val16 int16, val8 int8, shi
func provedUnsignedShiftRight(val64 uint64, val32 uint32, val16 uint16, val8 uint8, shift int) (r1 uint64, r2 uint32, r3 uint16, r4 uint8) {
if shift >= 0 && shift < 64 {
// arm64:"LSR",-"CSEL"
// arm64:"LSR" -"CSEL"
r1 = val64 >> shift
}
if shift >= 0 && shift < 32 {
// arm64:"LSR",-"CSEL"
// arm64:"LSR" -"CSEL"
r2 = val32 >> shift
}
if shift >= 0 && shift < 16 {
// arm64:"LSR",-"CSEL"
// arm64:"LSR" -"CSEL"
r3 = val16 >> shift
}
if shift >= 0 && shift < 8 {
// arm64:"LSR",-"CSEL"
// arm64:"LSR" -"CSEL"
r4 = val8 >> shift
}
return r1, r2, r3, r4
@ -409,19 +409,19 @@ func provedUnsignedShiftRight(val64 uint64, val32 uint32, val16 uint16, val8 uin
func provedSignedShiftRight(val64 int64, val32 int32, val16 int16, val8 int8, shift int) (r1 int64, r2 int32, r3 int16, r4 int8) {
if shift >= 0 && shift < 64 {
// arm64:"ASR",-"CSEL"
// arm64:"ASR" -"CSEL"
r1 = val64 >> shift
}
if shift >= 0 && shift < 32 {
// arm64:"ASR",-"CSEL"
// arm64:"ASR" -"CSEL"
r2 = val32 >> shift
}
if shift >= 0 && shift < 16 {
// arm64:"ASR",-"CSEL"
// arm64:"ASR" -"CSEL"
r3 = val16 >> shift
}
if shift >= 0 && shift < 8 {
// arm64:"ASR",-"CSEL"
// arm64:"ASR" -"CSEL"
r4 = val8 >> shift
}
return r1, r2, r3, r4
@ -429,36 +429,36 @@ func provedSignedShiftRight(val64 int64, val32 int32, val16 int16, val8 int8, sh
func checkUnneededTrunc(tab *[100000]uint32, d uint64, v uint32, h uint16, b byte) (uint32, uint64) {
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
f := tab[byte(v)^b]
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
f += tab[byte(v)&b]
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
f += tab[byte(v)|b]
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
f += tab[uint16(v)&h]
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
f += tab[uint16(v)^h]
// ppc64x:-".*RLWINM",-".*RLDICR",".*CLRLSLDI"
// ppc64x:-".*RLWINM" -".*RLDICR" ".*CLRLSLDI"
f += tab[uint16(v)|h]
// ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI"
// ppc64x:-".*AND" -"RLDICR" ".*CLRLSLDI"
f += tab[v&0xff]
// ppc64x:-".*AND",".*CLRLSLWI"
// ppc64x:-".*AND" ".*CLRLSLWI"
f += 2 * uint32(uint16(d))
// ppc64x:-".*AND",-"RLDICR",".*CLRLSLDI"
// ppc64x:-".*AND" -"RLDICR" ".*CLRLSLDI"
g := 2 * uint64(uint32(d))
return f, g
}
func checkCombinedShifts(v8 uint8, v16 uint16, v32 uint32, x32 int32, v64 uint64) (uint8, uint16, uint32, uint64, int64) {
// ppc64x:-"AND","CLRLSLWI"
// ppc64x:-"AND" "CLRLSLWI"
f := (v8 & 0xF) << 2
// ppc64x:"CLRLSLWI"
f += byte(v16) << 3
// ppc64x:-"AND","CLRLSLWI"
// ppc64x:-"AND" "CLRLSLWI"
g := (v16 & 0xFF) << 3
// ppc64x:-"AND","CLRLSLWI"
// ppc64x:-"AND" "CLRLSLWI"
h := (v32 & 0xFFFFF) << 2
// ppc64x:"CLRLSLDI"
i := (v64 & 0xFFFFFFFF) << 5
@ -466,7 +466,7 @@ func checkCombinedShifts(v8 uint8, v16 uint16, v32 uint32, x32 int32, v64 uint64
i += (v64 & 0xFFFFFFF) << 38
// ppc64x/power9:-"CLRLSLDI"
i += (v64 & 0xFFFF00) << 10
// ppc64x/power9:-"SLD","EXTSWSLI"
// ppc64x/power9:-"SLD" "EXTSWSLI"
j := int64(x32+32) * 8
return f, g, h, i, j
}
@ -497,71 +497,71 @@ func checkWidenAfterShift(v int64, u uint64) (int64, uint64) {
func checkShiftAndMask32(v []uint32) {
i := 0
// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
// ppc64x: "RLWNM [$]24, R[0-9]+, [$]12, [$]19, R[0-9]+"
v[i] = (v[i] & 0xFF00000) >> 8
i++
// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
// ppc64x: "RLWNM [$]26, R[0-9]+, [$]22, [$]29, R[0-9]+"
v[i] = (v[i] & 0xFF00) >> 6
i++
// ppc64x: "MOVW\tR0"
// ppc64x: "MOVW R0"
v[i] = (v[i] & 0xFF) >> 8
i++
// ppc64x: "MOVW\tR0"
// ppc64x: "MOVW R0"
v[i] = (v[i] & 0xF000000) >> 28
i++
// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
// ppc64x: "RLWNM [$]26, R[0-9]+, [$]24, [$]31, R[0-9]+"
v[i] = (v[i] >> 6) & 0xFF
i++
// ppc64x: "RLWNM\t[$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
// ppc64x: "RLWNM [$]26, R[0-9]+, [$]12, [$]19, R[0-9]+"
v[i] = (v[i] >> 6) & 0xFF000
i++
// ppc64x: "MOVW\tR0"
// ppc64x: "MOVW R0"
v[i] = (v[i] >> 20) & 0xFF000
i++
// ppc64x: "MOVW\tR0"
// ppc64x: "MOVW R0"
v[i] = (v[i] >> 24) & 0xFF00
i++
}
func checkMergedShifts32(a [256]uint32, b [256]uint64, u uint32, v uint32) {
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
// ppc64x: -"CLRLSLDI", "RLWNM [$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
a[0] = a[uint8(v>>24)]
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
// ppc64x: -"CLRLSLDI", "RLWNM [$]11, R[0-9]+, [$]21, [$]28, R[0-9]+"
b[0] = b[uint8(v>>24)]
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
// ppc64x: -"CLRLSLDI", "RLWNM [$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
b[1] = b[(v>>20)&0xFF]
// ppc64x: -"SLD", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
// ppc64x: -"SLD", "RLWNM [$]10, R[0-9]+, [$]22, [$]28, R[0-9]+"
b[2] = b[v>>25]
}
func checkMergedShifts64(a [256]uint32, b [256]uint64, c [256]byte, v uint64) {
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
// ppc64x: -"CLRLSLDI", "RLWNM [$]10, R[0-9]+, [$]22, [$]29, R[0-9]+"
a[0] = a[uint8(v>>24)]
// ppc64x: "SRD", "CLRLSLDI", -"RLWNM"
a[1] = a[uint8(v>>25)]
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]9, R[0-9]+, [$]23, [$]29, R[0-9]+"
// ppc64x: -"CLRLSLDI", "RLWNM [$]9, R[0-9]+, [$]23, [$]29, R[0-9]+"
a[2] = a[v>>25&0x7F]
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]3, R[0-9]+, [$]29, [$]29, R[0-9]+"
// ppc64x: -"CLRLSLDI", "RLWNM [$]3, R[0-9]+, [$]29, [$]29, R[0-9]+"
a[3] = a[(v>>31)&0x01]
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]12, R[0-9]+, [$]21, [$]28, R[0-9]+"
// ppc64x: -"CLRLSLDI", "RLWNM [$]12, R[0-9]+, [$]21, [$]28, R[0-9]+"
b[0] = b[uint8(v>>23)]
// ppc64x: -"CLRLSLDI", "RLWNM\t[$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
// ppc64x: -"CLRLSLDI", "RLWNM [$]15, R[0-9]+, [$]21, [$]28, R[0-9]+"
b[1] = b[(v>>20)&0xFF]
// ppc64x: "RLWNM", -"SLD"
b[2] = b[((uint64((uint32(v) >> 21)) & 0x3f) << 4)]
// ppc64x: -"RLWNM"
b[3] = (b[3] << 24) & 0xFFFFFF000000
// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]0, [$]7,"
// ppc64x: "RLWNM [$]24, R[0-9]+, [$]0, [$]7,"
b[4] = (b[4] << 24) & 0xFF000000
// ppc64x: "RLWNM\t[$]24, R[0-9]+, [$]0, [$]7,"
// ppc64x: "RLWNM [$]24, R[0-9]+, [$]0, [$]7,"
b[5] = (b[5] << 24) & 0xFF00000F
// ppc64x: -"RLWNM"
b[6] = (b[6] << 0) & 0xFF00000F
// ppc64x: "RLWNM\t[$]4, R[0-9]+, [$]28, [$]31,"
// ppc64x: "RLWNM [$]4, R[0-9]+, [$]28, [$]31,"
b[7] = (b[7] >> 28) & 0xF
// ppc64x: "RLWNM\t[$]11, R[0-9]+, [$]10, [$]15"
// ppc64x: "RLWNM [$]11, R[0-9]+, [$]10, [$]15"
c[0] = c[((v>>5)&0x3F)<<16]
// ppc64x: "ANDCC\t[$]8064,"
// ppc64x: "ANDCC [$]8064,"
c[1] = c[((v>>7)&0x3F)<<7]
}
@ -572,7 +572,7 @@ func checkShiftMask(a uint32, b uint64, z []uint32, y []uint64) {
z[0] = uint32(uint8(a >> 5))
// ppc64x: -"MOVBZ", -"SRW", "RLWNM"
z[1] = uint32(uint8((a >> 4) & 0x7e))
// ppc64x: "RLWNM\t[$]25, R[0-9]+, [$]27, [$]29, R[0-9]+"
// ppc64x: "RLWNM [$]25, R[0-9]+, [$]27, [$]29, R[0-9]+"
z[2] = uint32(uint8(a>>7)) & 0x1c
// ppc64x: -"MOVWZ"
y[0] = uint64((a >> 6) & 0x1c)
@ -598,11 +598,11 @@ func check128bitShifts(x, y uint64, bits uint) (uint64, uint64) {
}
func checkShiftToMask(u []uint64, s []int64) {
// amd64:-"SHR",-"SHL","ANDQ"
// amd64:-"SHR" -"SHL" "ANDQ"
u[0] = u[0] >> 5 << 5
// amd64:-"SAR",-"SHL","ANDQ"
// amd64:-"SAR" -"SHL" "ANDQ"
s[0] = s[0] >> 5 << 5
// amd64:-"SHR",-"SHL","ANDQ"
// amd64:-"SHR" -"SHL" "ANDQ"
u[1] = u[1] << 5 >> 5
}
@ -611,13 +611,13 @@ func checkShiftToMask(u []uint64, s []int64) {
//
func checkLeftShiftWithAddition(a int64, b int64) int64 {
// riscv64/rva20u64: "SLLI","ADD"
// riscv64/rva20u64: "SLLI" "ADD"
// riscv64/rva22u64,riscv64/rva23u64: "SH1ADD"
a = a + b<<1
// riscv64/rva20u64: "SLLI","ADD"
// riscv64/rva20u64: "SLLI" "ADD"
// riscv64/rva22u64,riscv64/rva23u64: "SH2ADD"
a = a + b<<2
// riscv64/rva20u64: "SLLI","ADD"
// riscv64/rva20u64: "SLLI" "ADD"
// riscv64/rva22u64,riscv64/rva23u64: "SH3ADD"
a = a + b<<3
return a
@ -631,7 +631,7 @@ func rsh64Uto32U(v uint64) uint32 {
x := uint32(v)
// riscv64:"MOVWU"
if x > 8 {
// riscv64:"SRLIW",-"MOVWU",-"SLLI"
// riscv64:"SRLIW" -"MOVWU" -"SLLI"
x >>= 2
}
return x
@ -641,7 +641,7 @@ func rsh64Uto16U(v uint64) uint16 {
x := uint16(v)
// riscv64:"MOVHU"
if x > 8 {
// riscv64:"SLLI","SRLI"
// riscv64:"SLLI" "SRLI"
x >>= 2
}
return x
@ -651,7 +651,7 @@ func rsh64Uto8U(v uint64) uint8 {
x := uint8(v)
// riscv64:"MOVBU"
if x > 8 {
// riscv64:"SLLI","SRLI"
// riscv64:"SLLI" "SRLI"
x >>= 2
}
return x
@ -661,7 +661,7 @@ func rsh64to32(v int64) int32 {
x := int32(v)
// riscv64:"MOVW"
if x > 8 {
// riscv64:"SRAIW",-"MOVW",-"SLLI"
// riscv64:"SRAIW" -"MOVW" -"SLLI"
x >>= 2
}
return x
@ -671,7 +671,7 @@ func rsh64to16(v int64) int16 {
x := int16(v)
// riscv64:"MOVH"
if x > 8 {
// riscv64:"SLLI","SRAI"
// riscv64:"SLLI" "SRAI"
x >>= 2
}
return x
@ -681,7 +681,7 @@ func rsh64to8(v int64) int8 {
x := int8(v)
// riscv64:"MOVB"
if x > 8 {
// riscv64:"SLLI","SRAI"
// riscv64:"SLLI" "SRAI"
x >>= 2
}
return x
@ -692,6 +692,6 @@ func rsh64to8(v int64) int8 {
// (There is still a negative shift test, but
// no shift-too-big test.)
func signedModShift(i int) int64 {
// arm64:-"CMP",-"CSEL"
// arm64:-"CMP" -"CSEL"
return 1 << (i % 64)
}

22
test/codegen/slices.go
View file

@ -46,7 +46,7 @@ func SliceExtensionConst(s []int) []int {
// amd64:-`.*runtime\.memclrNoHeapPointers`
// amd64:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.panicmakeslicelen`
// amd64:"MOVUPS\tX15"
// amd64:"MOVUPS X15"
// loong64:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.makeslice`
@ -58,7 +58,7 @@ func SliceExtensionConstInt64(s []int) []int {
// amd64:-`.*runtime\.memclrNoHeapPointers`
// amd64:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.panicmakeslicelen`
// amd64:"MOVUPS\tX15"
// amd64:"MOVUPS X15"
// loong64:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.makeslice`
@ -70,7 +70,7 @@ func SliceExtensionConstUint64(s []int) []int {
// amd64:-`.*runtime\.memclrNoHeapPointers`
// amd64:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.panicmakeslicelen`
// amd64:"MOVUPS\tX15"
// amd64:"MOVUPS X15"
// loong64:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.makeslice`
@ -82,7 +82,7 @@ func SliceExtensionConstUint(s []int) []int {
// amd64:-`.*runtime\.memclrNoHeapPointers`
// amd64:-`.*runtime\.makeslice`
// amd64:-`.*runtime\.panicmakeslicelen`
// amd64:"MOVUPS\tX15"
// amd64:"MOVUPS X15"
// loong64:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.memclrNoHeapPointers`
// ppc64x:-`.*runtime\.makeslice`
@ -352,12 +352,12 @@ func SliceNilCheck(s []int) {
// ---------------------- //
// See issue 21561
func InitSmallSliceLiteral() []int {
// amd64:`MOVQ\t[$]42`
// amd64:`MOVQ [$]42`
return []int{42}
}
func InitNotSmallSliceLiteral() []int {
// amd64:`LEAQ\t.*stmp_`
// amd64:`LEAQ .*stmp_`
return []int{
42,
42,
@ -413,7 +413,7 @@ func SliceWithConstCompare(a []int, b int) []int {
}
func SliceWithSubtractBound(a []int, b int) []int {
// ppc64x:"SUBC",-"NEG"
// ppc64x:"SUBC" -"NEG"
return a[(3 - b):]
}
@ -422,7 +422,7 @@ func SliceWithSubtractBound(a []int, b int) []int {
// --------------------------------------- //
func SliceAndIndex(a []int, b int) int {
// arm64:"AND\tR[0-9]+->63","ADD\tR[0-9]+<<3"
// arm64:"AND R[0-9]+->63" "ADD R[0-9]+<<3"
return a[b:][b]
}
@ -445,12 +445,12 @@ func Slice0(p *struct{}, i int) []struct{} {
// --------------------------------------- //
func SlicePut(a []byte, c uint8) []byte {
// arm64:`CBZ\tR1`
// arm64:`CBZ R1`
a[0] = c
// arm64:`CMP\t\$1, R1`
// arm64:`CMP \$1, R1`
a = a[1:]
a[0] = c
// arm64:`CMP\t\$2, R1`
// arm64:`CMP \$2, R1`
a = a[1:]
a[0] = c
a = a[1:]

6
test/codegen/smallintiface.go
View file

@ -7,16 +7,16 @@ package codegen
// license that can be found in the LICENSE file.
func booliface() interface{} {
// amd64:`LEAQ\truntime.staticuint64s\+8\(SB\)`
// amd64:`LEAQ runtime.staticuint64s\+8\(SB\)`
return true
}
func smallint8iface() interface{} {
// amd64:`LEAQ\truntime.staticuint64s\+2024\(SB\)`
// amd64:`LEAQ runtime.staticuint64s\+2024\(SB\)`
return int8(-3)
}
func smalluint8iface() interface{} {
// amd64:`LEAQ\truntime.staticuint64s\+24\(SB\)`
// amd64:`LEAQ runtime.staticuint64s\+24\(SB\)`
return uint8(3)
}

70
test/codegen/stack.go
View file

@ -16,13 +16,13 @@ import (
// Check that stack stores are optimized away.
// 386:"TEXT\t.*, [$]0-"
// amd64:"TEXT\t.*, [$]0-"
// arm:"TEXT\t.*, [$]-4-"
// arm64:"TEXT\t.*, [$]0-"
// mips:"TEXT\t.*, [$]-4-"
// ppc64x:"TEXT\t.*, [$]0-"
// s390x:"TEXT\t.*, [$]0-"
// 386:"TEXT .*, [$]0-"
// amd64:"TEXT .*, [$]0-"
// arm:"TEXT .*, [$]-4-"
// arm64:"TEXT .*, [$]0-"
// mips:"TEXT .*, [$]-4-"
// ppc64x:"TEXT .*, [$]0-"
// s390x:"TEXT .*, [$]0-"
func StackStore() int {
var x int
return *(&x)
@ -35,13 +35,13 @@ type T struct {
// Check that large structs are cleared directly (issue #24416).
// 386:"TEXT\t.*, [$]0-"
// amd64:"TEXT\t.*, [$]0-"
// arm:"TEXT\t.*, [$]0-" (spills return address)
// arm64:"TEXT\t.*, [$]0-"
// mips:"TEXT\t.*, [$]-4-"
// ppc64x:"TEXT\t.*, [$]0-"
// s390x:"TEXT\t.*, [$]0-"
// 386:"TEXT .*, [$]0-"
// amd64:"TEXT .*, [$]0-"
// arm:"TEXT .*, [$]0-" (spills return address)
// arm64:"TEXT .*, [$]0-"
// mips:"TEXT .*, [$]-4-"
// ppc64x:"TEXT .*, [$]0-"
// s390x:"TEXT .*, [$]0-"
func ZeroLargeStruct(x *T) {
t := T{}
*x = t
@ -51,11 +51,11 @@ func ZeroLargeStruct(x *T) {
// Notes:
// - 386 fails due to spilling a register
// amd64:"TEXT\t.*, [$]0-"
// arm:"TEXT\t.*, [$]0-" (spills return address)
// arm64:"TEXT\t.*, [$]0-"
// ppc64x:"TEXT\t.*, [$]0-"
// s390x:"TEXT\t.*, [$]0-"
// amd64:"TEXT .*, [$]0-"
// arm:"TEXT .*, [$]0-" (spills return address)
// arm64:"TEXT .*, [$]0-"
// ppc64x:"TEXT .*, [$]0-"
// s390x:"TEXT .*, [$]0-"
// Note: that 386 currently has to spill a register.
func KeepWanted(t *T) {
*t = T{A: t.A, B: t.B, C: t.C, D: t.D}
@ -66,23 +66,23 @@ func KeepWanted(t *T) {
// Notes:
// - 386 fails due to spilling a register
// - arm & mips fail due to softfloat calls
// amd64:"TEXT\t.*, [$]0-"
// arm64:"TEXT\t.*, [$]0-"
// ppc64x:"TEXT\t.*, [$]0-"
// s390x:"TEXT\t.*, [$]0-"
// amd64:"TEXT .*, [$]0-"
// arm64:"TEXT .*, [$]0-"
// ppc64x:"TEXT .*, [$]0-"
// s390x:"TEXT .*, [$]0-"
func ArrayAdd64(a, b [4]float64) [4]float64 {
return [4]float64{a[0] + b[0], a[1] + b[1], a[2] + b[2], a[3] + b[3]}
}
// Check that small array initialization avoids using the stack.
// 386:"TEXT\t.*, [$]0-"
// amd64:"TEXT\t.*, [$]0-"
// arm:"TEXT\t.*, [$]0-" (spills return address)
// arm64:"TEXT\t.*, [$]0-"
// mips:"TEXT\t.*, [$]-4-"
// ppc64x:"TEXT\t.*, [$]0-"
// s390x:"TEXT\t.*, [$]0-"
// 386:"TEXT .*, [$]0-"
// amd64:"TEXT .*, [$]0-"
// arm:"TEXT .*, [$]0-" (spills return address)
// arm64:"TEXT .*, [$]0-"
// mips:"TEXT .*, [$]-4-"
// ppc64x:"TEXT .*, [$]0-"
// s390x:"TEXT .*, [$]0-"
func ArrayInit(i, j int) [4]int {
return [4]int{i, 0, j, 0}
}
@ -99,7 +99,7 @@ func check_asmout(b [2]int) int {
// Check that simple functions get promoted to nosplit, even when
// they might panic in various ways. See issue 31219.
// amd64:"TEXT\t.*NOSPLIT.*"
// amd64:"TEXT .*NOSPLIT.*"
func MightPanic(a []int, i, j, k, s int) {
_ = a[i] // panicIndex
_ = a[i:j] // panicSlice
@ -113,7 +113,7 @@ func Defer() {
for i := 0; i < 2; i++ {
defer func() {}()
}
// amd64:`CALL\truntime\.deferprocStack`
// amd64:`CALL runtime\.deferprocStack`
defer func() {}()
}
@ -138,7 +138,7 @@ type mySlice struct {
cap int
}
// amd64:"TEXT\t.*, [$]0-"
// amd64:"TEXT .*, [$]0-"
func sliceInit(base uintptr) []uintptr {
const ptrSize = 8
size := uintptr(4096)
@ -150,7 +150,7 @@ func sliceInit(base uintptr) []uintptr {
elements,
elements,
}
// amd64:-"POPQ",-"SP"
// amd64:-"POPQ" -"SP"
return *(*[]uintptr)(unsafe.Pointer(&sl))
}
@ -171,6 +171,6 @@ func getp2() *[4]int {
// Store to an argument without read can be removed.
func storeArg(a [2]int) {
// amd64:-`MOVQ\t\$123,.*\.a\+\d+\(SP\)`
// amd64:-`MOVQ \$123,.*\.a\+\d+\(SP\)`
a[1] = 123
}

54
test/codegen/strings.go
View file

@ -22,8 +22,8 @@ func CountBytes(s []byte) int {
}
func ToByteSlice() []byte { // Issue #24698
// amd64:`LEAQ\ttype:\[3\]uint8`
// amd64:`CALL\truntime\.newobject`
// amd64:`LEAQ type:\[3\]uint8`
// amd64:`CALL runtime\.mallocTiny3`
// amd64:-`.*runtime.stringtoslicebyte`
return []byte("foo")
}
@ -37,56 +37,56 @@ func ConvertToByteSlice(a, b, c string) []byte {
func ConstantLoad() {
// 12592 = 0x3130
// 50 = 0x32
// amd64:`MOVW\t\$12592, \(`,`MOVB\t\$50, 2\(`
// 386:`MOVW\t\$12592, \(`,`MOVB\t\$50, 2\(`
// arm:`MOVW\t\$48`,`MOVW\t\$49`,`MOVW\t\$50`
// arm64:`MOVD\t\$12592`,`MOVD\t\$50`
// loong64:`MOVV\t\$12592`,`MOVV\t\$50`
// wasm:`I64Const\t\$12592`,`I64Store16\t\$0`,`I64Const\t\$50`,`I64Store8\t\$2`
// mips64:`MOVV\t\$48`,`MOVV\t\$49`,`MOVV\t\$50`
// amd64:`MOVW \$12592, \(`,`MOVB \$50, 2\(`
// 386:`MOVW \$12592, \(`,`MOVB \$50, 2\(`
// arm:`MOVW \$48`,`MOVW \$49`,`MOVW \$50`
// arm64:`MOVD \$12592`,`MOVD \$50`
// loong64:`MOVV \$12592`,`MOVV \$50`
// wasm:`I64Const \$12592`,`I64Store16 \$0`,`I64Const \$50`,`I64Store8 \$2`
// mips64:`MOVV \$48`,`MOVV \$49`,`MOVV \$50`
bsink = []byte("012")
// 858927408 = 0x33323130
// 13620 = 0x3534
// amd64:`MOVL\t\$858927408`,`MOVW\t\$13620, 4\(`
// 386:`MOVL\t\$858927408`,`MOVW\t\$13620, 4\(`
// arm64:`MOVD\t\$858927408`,`MOVD\t\$13620`
// loong64:`MOVV\t\$858927408`,`MOVV\t\$13620`
// wasm:`I64Const\t\$858927408`,`I64Store32\t\$0`,`I64Const\t\$13620`,`I64Store16\t\$4`
// amd64:`MOVL \$858927408`,`MOVW \$13620, 4\(`
// 386:`MOVL \$858927408`,`MOVW \$13620, 4\(`
// arm64:`MOVD \$858927408`,`MOVD \$13620`
// loong64:`MOVV \$858927408`,`MOVV \$13620`
// wasm:`I64Const \$858927408`,`I64Store32 \$0`,`I64Const \$13620`,`I64Store16 \$4`
bsink = []byte("012345")
// 3978425819141910832 = 0x3736353433323130
// 7306073769690871863 = 0x6564636261393837
// amd64:`MOVQ\t\$3978425819141910832`,`MOVQ\t\$7306073769690871863`
// 386:`MOVL\t\$858927408, \(`,`DUFFCOPY`
// arm64:`MOVD\t\$3978425819141910832`,`MOVD\t\$7306073769690871863`,`MOVD\t\$15`
// loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$7306073769690871863`,`MOVV\t\$15`
// wasm:`I64Const\t\$3978425819141910832`,`I64Store\t\$0`,`I64Const\t\$7306073769690871863`,`I64Store\t\$7`
// amd64:`MOVQ \$3978425819141910832`,`MOVQ \$7306073769690871863`
// 386:`MOVL \$858927408, \(`,`DUFFCOPY`
// arm64:`MOVD \$3978425819141910832`,`MOVD \$7306073769690871863`,`MOVD \$15`
// loong64:`MOVV \$3978425819141910832`,`MOVV \$7306073769690871863`,`MOVV \$15`
// wasm:`I64Const \$3978425819141910832`,`I64Store \$0`,`I64Const \$7306073769690871863`,`I64Store \$7`
bsink = []byte("0123456789abcde")
// 56 = 0x38
// amd64:`MOVQ\t\$3978425819141910832`,`MOVB\t\$56`
// loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$56`
// amd64:`MOVQ \$3978425819141910832`,`MOVB \$56`
// loong64:`MOVV \$3978425819141910832`,`MOVV \$56`
bsink = []byte("012345678")
// 14648 = 0x3938
// amd64:`MOVQ\t\$3978425819141910832`,`MOVW\t\$14648`
// loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$14648`
// amd64:`MOVQ \$3978425819141910832`,`MOVW \$14648`
// loong64:`MOVV \$3978425819141910832`,`MOVV \$14648`
bsink = []byte("0123456789")
// 1650538808 = 0x62613938
// amd64:`MOVQ\t\$3978425819141910832`,`MOVL\t\$1650538808`
// loong64:`MOVV\t\$3978425819141910832`,`MOVV\t\$1650538808`
// amd64:`MOVQ \$3978425819141910832`,`MOVL \$1650538808`
// loong64:`MOVV \$3978425819141910832`,`MOVV \$1650538808`
bsink = []byte("0123456789ab")
}
// self-equality is always true. See issue 60777.
func EqualSelf(s string) bool {
// amd64:`MOVL\t\$1, AX`,-`.*memequal.*`
// amd64:`MOVL \$1, AX`,-`.*memequal.*`
return s == s
}
func NotEqualSelf(s string) bool {
// amd64:`XORL\tAX, AX`,-`.*memequal.*`
// amd64:`XORL AX, AX`,-`.*memequal.*`
return s != s
}

6
test/codegen/structs.go
View file

@ -20,7 +20,7 @@ type Z1 struct {
}
func Zero1(t *Z1) { // Issue #18370
// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
// amd64:`MOVUPS X[0-9]+, \(.*\)`,`MOVQ \$0, 16\(.*\)`
*t = Z1{}
}
@ -29,7 +29,7 @@ type Z2 struct {
}
func Zero2(t *Z2) {
// amd64:`MOVUPS\tX[0-9]+, \(.*\)`,`MOVQ\t\$0, 16\(.*\)`
// amd64:`MOVUPS X[0-9]+, \(.*\)`,`MOVQ \$0, 16\(.*\)`
// amd64:`.*runtime[.]gcWriteBarrier.*\(SB\)`
*t = Z2{}
}
@ -43,6 +43,6 @@ type I1 struct {
}
func Init1(p *I1) { // Issue #18872
// amd64:`MOVQ\t[$]1`,`MOVQ\t[$]2`,`MOVQ\t[$]3`,`MOVQ\t[$]4`
// amd64:`MOVQ [$]1`,`MOVQ [$]2`,`MOVQ [$]3`,`MOVQ [$]4`
*p = I1{1, 2, 3, 4}
}

24
test/codegen/switch.go
View file

@ -137,8 +137,8 @@ type K interface {
// use a runtime call for type switches to interface types.
func interfaceSwitch(x any) int {
// amd64:`CALL\truntime.interfaceSwitch`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*8)`
// arm64:`CALL\truntime.interfaceSwitch`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
// amd64:`CALL runtime.interfaceSwitch`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*8)`
// arm64:`CALL runtime.interfaceSwitch`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
switch x.(type) {
case I:
return 1
@ -150,8 +150,8 @@ func interfaceSwitch(x any) int {
}
func interfaceSwitch2(x K) int {
// amd64:`CALL\truntime.interfaceSwitch`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*8)`
// arm64:`CALL\truntime.interfaceSwitch`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
// amd64:`CALL runtime.interfaceSwitch`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*8)`
// arm64:`CALL runtime.interfaceSwitch`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
switch x.(type) {
case I:
return 1
@ -163,8 +163,8 @@ func interfaceSwitch2(x K) int {
}
func interfaceCast(x any) int {
// amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*1)`
// arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
// amd64:`CALL runtime.typeAssert`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*1)`
// arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
if _, ok := x.(I); ok {
return 3
}
@ -172,8 +172,8 @@ func interfaceCast(x any) int {
}
func interfaceCast2(x K) int {
// amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*1)`
// arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
// amd64:`CALL runtime.typeAssert`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*1)`
// arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
if _, ok := x.(I); ok {
return 3
}
@ -181,8 +181,8 @@ func interfaceCast2(x K) int {
}
func interfaceConv(x IJ) I {
// amd64:`CALL\truntime.typeAssert`,`MOVL\t16\(AX\)`,`MOVQ\t8\(.*\)(.*\*1)`
// arm64:`CALL\truntime.typeAssert`,`LDAR`,`MOVWU\t16\(R0\)`,`MOVD\t\(R.*\)\(R.*\)`
// amd64:`CALL runtime.typeAssert`,`MOVL 16\(AX\)`,`MOVQ 8\(.*\)(.*\*1)`
// arm64:`CALL runtime.typeAssert`,`LDAR`,`MOVWU 16\(R0\)`,`MOVD \(R.*\)\(R.*\)`
return x
}
@ -195,7 +195,7 @@ func stringSwitchInlineable(s string) {
}
}
func stringSwitch() {
// amd64:-"CMP",-"CALL"
// arm64:-"CMP",-"CALL"
// amd64:-"CMP" -"CALL"
// arm64:-"CMP" -"CALL"
stringSwitchInlineable("foo")
}

6
test/codegen/typeswitch.go
View file

@ -37,7 +37,7 @@ func swGYZ[T any](a Ig[T]) {
t.Y()
case Iz: // amd64:-".*typeAssert"
t.Z()
case interface{ G() T }: // amd64:-".*typeAssert",-".*assertE2I\\(",".*assertE2I2"
case interface{ G() T }: // amd64:-".*typeAssert" -".*assertE2I\\(" ".*assertE2I2"
t.G()
}
}
@ -46,7 +46,7 @@ func swE2G[T any](a any) {
switch t := a.(type) {
case Iy:
t.Y()
case Ig[T]: // amd64:-".*assertE2I\\(",".*assertE2I2"
case Ig[T]: // amd64:-".*assertE2I\\(" ".*assertE2I2"
t.G()
}
}
@ -55,7 +55,7 @@ func swI2G[T any](a Ix) {
switch t := a.(type) {
case Iy:
t.Y()
case Ig[T]: // amd64:-".*assertE2I\\(",".*assertE2I2"
case Ig[T]: // amd64:-".*assertE2I\\(" ".*assertE2I2"
t.G()
}
}

8
test/codegen/zerosize.go
View file

@ -12,24 +12,24 @@ package codegen
func zeroSize() {
c := make(chan struct{})
// amd64:`MOVQ\t\$0, command-line-arguments\.s\+56\(SP\)`
// amd64:`MOVQ \$0, command-line-arguments\.s\+56\(SP\)`
var s *int
// force s to be a stack object, also use some (fixed) stack space
g(&s, 1, 2, 3, 4, 5)
// amd64:`LEAQ\tcommand-line-arguments\..*\+55\(SP\)`
// amd64:`LEAQ command-line-arguments\..*\+55\(SP\)`
c <- noliteral(struct{}{})
}
// Like zeroSize, but without hiding the zero-sized struct.
func zeroSize2() {
c := make(chan struct{})
// amd64:`MOVQ\t\$0, command-line-arguments\.s\+48\(SP\)`
// amd64:`MOVQ \$0, command-line-arguments\.s\+48\(SP\)`
var s *int
// force s to be a stack object, also use some (fixed) stack space
g(&s, 1, 2, 3, 4, 5)
// amd64:`LEAQ\tcommand-line-arguments\..*stmp_\d+\(SB\)`
// amd64:`LEAQ command-line-arguments\..*stmp_\d+\(SB\)`
c <- struct{}{}
}