pax_global_header00006660000000000000000000000064151212405300014503gustar00rootroot0000000000000052 comment=8b9b98cedd6ca1f95f6d33409dbdcaa7c9c62e17 golang-github-ebitengine-purego-0.9.1/000077500000000000000000000000001512124053000176475ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/.github/000077500000000000000000000000001512124053000212075ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/.github/ISSUE_TEMPLATE/000077500000000000000000000000001512124053000233725ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/.github/ISSUE_TEMPLATE/00-bug.yml000066400000000000000000000020321512124053000251040ustar00rootroot00000000000000name: Bug Report description: Report a bug you've found. labels: bug body: - type: input id: version_of_purego attributes: label: PureGo Version validations: required: true - type: checkboxes id: os attributes: label: Operating System options: - label: Windows - label: macOS - label: Linux - label: FreeBSD - label: NetBSD - label: Android - label: iOS validations: required: true - type: input id: version_of_go attributes: label: Go Version (`go version`) validations: required: true - type: textarea id: repro_steps attributes: label: What steps will reproduce the problem? validations: required: true - type: textarea id: expected_result attributes: label: What is the expected result? validations: required: true - type: textarea id: actual_result attributes: label: What happens instead? validations: required: true - type: textarea id: additional attributes: label: Anything else you feel useful to add? golang-github-ebitengine-purego-0.9.1/.github/ISSUE_TEMPLATE/01-feature.yml000066400000000000000000000010671512124053000257720ustar00rootroot00000000000000name: Feature Request description: Provide details about a feature you'd like to see. labels: - feature - request body: - type: checkboxes id: os attributes: label: Operating System options: - label: Windows - label: macOS - label: Linux - label: FreeBSD - label: Android - label: iOS validations: required: true - type: textarea id: what attributes: label: What feature would you like to be added? validations: required: true - type: textarea id: why attributes: label: Why is this needed? golang-github-ebitengine-purego-0.9.1/.github/ISSUE_TEMPLATE/config.yml000066400000000000000000000003061512124053000253610ustar00rootroot00000000000000blank_issues_enabled: false contact_links: - name: Questions about: Please use one of the forums for questions or general discussions url: https://github.com/ebitengine/purego/discussions golang-github-ebitengine-purego-0.9.1/.github/PULL_REQUEST_TEMPLATE.md000066400000000000000000000005411512124053000250100ustar00rootroot00000000000000 # What issue is this addressing? ## What _type_ of issue is this addressing? ## What this PR does | solves golang-github-ebitengine-purego-0.9.1/.github/scripts/000077500000000000000000000000001512124053000226765ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/.github/scripts/bsd_tests.sh000077500000000000000000000053131512124053000252310ustar00rootroot00000000000000#!/bin/sh -e # SPDX-License-Identifier: Apache-2.0 # SPDX-FileCopyrightText: 2025 The Ebitengine Authors # BSD tests run within QEMU on Ubuntu. # vmactions/*-vm only supports a single "step" where it # brings down the VM at the end of the step, so all # the commands to run need to be put into this single block. echo "Running tests on $(uname -a) at $PWD" PATH=$PATH:/usr/local/go/bin/ # verify Go is available go version echo "=> go build" go build -v ./... # Compile without optimization to check potential stack overflow. # The option '-gcflags=all=-N -l' is often used at Visual Studio Code. # See also https://go.googlesource.com/vscode-go/+/HEAD/docs/debugging.md#launch and the issue hajimehoshi/ebiten#2120. go build "-gcflags=all=-N -l" -v ./... # Check cross-compiling Windows binaries. env GOOS=windows GOARCH=386 go build -v ./... env GOOS=windows GOARCH=amd64 go build -v ./... env GOOS=windows GOARCH=arm go build -v ./... env GOOS=windows GOARCH=arm64 go build -v ./... # Check cross-compiling macOS binaries. env GOOS=darwin GOARCH=amd64 go build -v ./... env GOOS=darwin GOARCH=arm64 go build -v ./... # Check cross-compiling Linux binaries. env GOOS=linux GOARCH=amd64 go build -v ./... env GOOS=linux GOARCH=arm64 go build -v ./... # Check cross-compiling FreeBSD binaries. env GOOS=freebsd GOARCH=amd64 go build -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -v ./... env GOOS=freebsd GOARCH=arm64 go build -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -v ./... # Check cross-compiling NetBSD binaries. env GOOS=netbsd GOARCH=amd64 go build -v ./... env GOOS=netbsd GOARCH=arm64 go build -v ./... echo "=> go build (plugin)" # Make sure that plugin buildmode works since we save the R15 register (#254) go build -buildmode=plugin ./examples/libc echo "=> go mod vendor" mkdir /tmp/vendoring cd /tmp/vendoring go mod init foo echo 'package main' > main.go echo 'import (' >> main.go echo ' _ "github.com/ebitengine/purego"' >> main.go echo ')' >> main.go echo 'func main() {}' >> main.go go mod edit -replace github.com/ebitengine/purego=$GITHUB_WORKSPACE go mod tidy go mod vendor go build -v . cd $GITHUB_WORKSPACE echo "=> go test CGO_ENABLED=0" env CGO_ENABLED=0 go test -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -shuffle=on -v -count=10 ./... echo "=> go test CGO_ENABLED=1" env CGO_ENABLED=1 go test -shuffle=on -v -count=10 ./... echo "=> go test CGO_ENABLED=0 w/o optimization" env CGO_ENABLED=0 go test "-gcflags=all=-N -l -std" -v ./... echo "=> go test CGO_ENABLED=1 w/o optimization" env CGO_ENABLED=1 go test "-gcflags=all=-N -l" -v ./... if [ -z "$(go version | grep '^1.1')" ]; then echo "=> go test race" go test -race -shuffle=on -v -count=10 ./... fi golang-github-ebitengine-purego-0.9.1/.github/workflows/000077500000000000000000000000001512124053000232445ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/.github/workflows/test.yml000066400000000000000000000215121512124053000247470ustar00rootroot00000000000000name: Test on: [push, pull_request] jobs: test: strategy: matrix: os: [ubuntu-latest, macos-latest, windows-latest] go: ['1.18.x', '1.19.x', '1.20.x', '1.21.x', '1.22.x', '1.23.x', '1.24.x', '1.25.x'] name: Test with Go ${{ matrix.go }} on ${{ matrix.os }} runs-on: ${{ matrix.os }} defaults: run: shell: bash steps: - name: Git run: | # See actions/checkout#135 git config --global core.autocrlf false git config --global core.eol lf - name: Checkout uses: actions/checkout@v4 - name: Setup Go uses: actions/setup-go@v5 with: go-version: ${{ matrix.go }} - name: Set up the prerequisites if: runner.os == 'Linux' run: | sudo apt-get update sudo apt-get install -y gcc-aarch64-linux-gnu g++-aarch64-linux-gnu gcc-14-loongarch64-linux-gnu g++-14-loongarch64-linux-gnu qemu-user - name: Set up the prerequisites if: runner.os == 'Windows' uses: msys2/setup-msys2@v2 - name: go vet run: | env CGO_ENABLED=0 go vet -v ./... - name: go build run: | go build -v ./... # Compile without optimization to check potential stack overflow. # The option '-gcflags=all=-N -l' is often used at Visual Studio Code. # See also https://go.googlesource.com/vscode-go/+/HEAD/docs/debugging.md#launch and the issue hajimehoshi/ebiten#2120. go build "-gcflags=all=-N -l" -v ./... # Check cross-compiling Windows binaries. env GOOS=windows GOARCH=386 go build -v ./... env GOOS=windows GOARCH=amd64 go build -v ./... env GOOS=windows GOARCH=arm go build -v ./... env GOOS=windows GOARCH=arm64 go build -v ./... # Check cross-compiling macOS binaries. env GOOS=darwin GOARCH=amd64 go build -v ./... env GOOS=darwin GOARCH=arm64 go build -v ./... # Check cross-compiling Linux binaries. env GOOS=linux GOARCH=amd64 go build -v ./... env GOOS=linux GOARCH=arm64 go build -v ./... # Check cross-compiling FreeBSD binaries. # gcflags -std is necessary to make fakecgo the Cgo for # FreeBSD to add the symbols that libc.so depends on. env GOOS=freebsd GOARCH=amd64 go build -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -v ./... env GOOS=freebsd GOARCH=arm64 go build -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" -v ./... # Check cross-compiling NetBSD binaries. env GOOS=netbsd GOARCH=amd64 go build -v ./... env GOOS=netbsd GOARCH=arm64 go build -v ./... - name: go build (Linux loong64) if: ${{ !startsWith(matrix.go, '1.18.') && !startsWith(matrix.go, '1.19.') && !startsWith(matrix.go, '1.20.') && !startsWith(matrix.go, '1.21.') && !startsWith(matrix.go, '1.22.') && !startsWith(matrix.go, '1.23.') && !startsWith(matrix.go, '1.24.') }} run: | # Check cross-compiling Linux binaries for loong64. # Loong64 support internal linking from go1.25. env GOOS=linux GOARCH=loong64 go build -v ./... - name: go build (plugin) if: runner.os == 'Linux' || runner.os == 'macOS' run: # Make sure that plugin buildmode works since we save the R15 register (#254) go build -buildmode=plugin ./examples/libc - name: go mod vendor if: runner.os != 'Linux' run: | mkdir /tmp/vendoring cd /tmp/vendoring go mod init foo echo 'package main' > main.go echo 'import (' >> main.go echo ' _ "github.com/ebitengine/purego"' >> main.go echo ')' >> main.go echo 'func main() {}' >> main.go go mod edit -replace github.com/ebitengine/purego=$GITHUB_WORKSPACE go mod tidy go mod vendor go build -v . - name: go test run: | env CGO_ENABLED=0 go test -shuffle=on -v -count=10 ./... env CGO_ENABLED=1 go test -shuffle=on -v -count=10 ./... # Compile without optimization to check potential stack overflow. # The option '-gcflags=all=-N -l' is often used at Visual Studio Code. # See also https://go.googlesource.com/vscode-go/+/HEAD/docs/debugging.md#launch. env CGO_ENABLED=0 go test "-gcflags=all=-N -l" -v ./... env CGO_ENABLED=1 go test "-gcflags=all=-N -l" -v ./... - name: go test (Linux arm64) if: runner.os == 'Linux' run: | go env -w CC=aarch64-linux-gnu-gcc go env -w CXX=aarch64-linux-gnu-g++ env GOOS=linux GOARCH=arm64 CGO_ENABLED=0 go test -c -o=purego-test-nocgo . env QEMU_LD_PREFIX=/usr/aarch64-linux-gnu qemu-aarch64 ./purego-test-nocgo -test.shuffle=on -test.v -test.count=10 env GOOS=linux GOARCH=arm64 CGO_ENABLED=1 go test -c -o=purego-test-cgo . env QEMU_LD_PREFIX=/usr/aarch64-linux-gnu qemu-aarch64 ./purego-test-cgo -test.shuffle=on -test.v -test.count=10 echo "=> go build (plugin)" # Make sure that plugin buildmode works since we save the R15 register (#254) env GOOS=linux GOARCH=arm64 CGO_ENABLED=1 go build -buildmode=plugin ./examples/libc go env -u CC go env -u CXX - name: go test (Linux loong64) if: ${{ runner.os == 'Linux' && !startsWith(matrix.go, '1.18.') && !startsWith(matrix.go, '1.19.') && !startsWith(matrix.go, '1.20.') && !startsWith(matrix.go, '1.21.') && !startsWith(matrix.go, '1.22.') && !startsWith(matrix.go, '1.23.') && !startsWith(matrix.go, '1.24.') }} run: | go env -w CC=loongarch64-linux-gnu-gcc-14 go env -w CXX=loongarch64-linux-gnu-g++-14 env GOOS=linux GOARCH=loong64 CGO_ENABLED=0 go test -c -o=purego-test-nocgo . env QEMU_LD_PREFIX=/usr/loongarch64-linux-gnu qemu-loongarch64 ./purego-test-nocgo -test.shuffle=on -test.v -test.count=10 env GOOS=linux GOARCH=loong64 CGO_ENABLED=1 go test -c -o=purego-test-cgo . env QEMU_LD_PREFIX=/usr/loongarch64-linux-gnu qemu-loongarch64 ./purego-test-cgo -test.shuffle=on -test.v -test.count=10 go env -u CC go env -u CXX - name: go test (Windows 386) if: runner.os == 'Windows' run: | env CGO_ENABLED=0 GOARCH=386 go test -shuffle=on -v -count=10 ./... env CGO_ENABLED=1 GOARCH=386 go test -shuffle=on -v -count=10 ./... - name: go test (Linux 386) if: runner.os == 'Linux' run: | sudo apt-get install gcc-multilib sudo apt-get install g++-multilib env CGO_ENABLED=1 GOARCH=386 go test -shuffle=on -v -count=10 ./... - name: go test race (no Cgo) if: ${{ runner.os == 'macOS' && !startsWith(matrix.go, '1.18.') && !startsWith(matrix.go, '1.19.') }} run: | # -race usually requires Cgo, but macOS is an exception. See https://go.dev/doc/articles/race_detector#Requirements env CGO_ENABLED=0 go test -race -shuffle=on -v -count=10 ./... - name: go test race (Cgo) if: ${{ !startsWith(matrix.go, '1.18.') && !startsWith(matrix.go, '1.19.') }} run: | env CGO_ENABLED=1 go test -race -shuffle=on -v -count=10 ./... bsd: strategy: matrix: os: ['FreeBSD'] # TODO: Add 'NetBSD' again (#304) go: ['1.18.10', '1.19.13', '1.20.14', '1.21.13', '1.22.12', '1.23.12', '1.24.6', '1.25.0'] exclude: # there are no prebuilt download links for these versions of Go for NetBSD - os: NetBSD go: '1.18.10' - os: NetBSD go: '1.19.13' - os: NetBSD go: '1.20.14' name: Test with Go ${{ matrix.go }} on ${{ matrix.os }} runs-on: ubuntu-22.04 defaults: run: shell: bash steps: - uses: actions/checkout@v4 - name: Run in FreeBSD if: matrix.os == 'FreeBSD' uses: vmactions/freebsd-vm@v1 with: usesh: true prepare: | fetch https://go.dev/dl/go${{matrix.go}}.freebsd-amd64.tar.gz rm -fr /usr/local/go && tar -C /usr/local -xf go${{matrix.go}}.freebsd-amd64.tar.gz chmod +x $GITHUB_WORKSPACE/.github/scripts/bsd_tests.sh run: $GITHUB_WORKSPACE/.github/scripts/bsd_tests.sh - name: Run in NetBSD if: matrix.os == 'NetBSD' uses: vmactions/netbsd-vm@v1 with: usesh: true prepare: | ftp https://go.dev/dl/go${{matrix.go}}.netbsd-amd64.tar.gz mkdir /usr/local rm -fr /usr/local/go && tar -C /usr/local -xf go${{matrix.go}}.netbsd-amd64.tar.gz chmod +x $GITHUB_WORKSPACE/.github/scripts/bsd_tests.sh run: $GITHUB_WORKSPACE/.github/scripts/bsd_tests.sh golang-github-ebitengine-purego-0.9.1/.gitignore000066400000000000000000000000031512124053000216300ustar00rootroot00000000000000*~ golang-github-ebitengine-purego-0.9.1/LICENSE000066400000000000000000000261351512124053000206630ustar00rootroot00000000000000 Apache License Version 2.0, January 2004 http://www.apache.org/licenses/ TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION 1. Definitions. "License" shall mean the terms and conditions for use, reproduction, and distribution as defined by Sections 1 through 9 of this document. "Licensor" shall mean the copyright owner or entity authorized by the copyright owner that is granting the License. "Legal Entity" shall mean the union of the acting entity and all other entities that control, are controlled by, or are under common control with that entity. For the purposes of this definition, "control" means (i) the power, direct or indirect, to cause the direction or management of such entity, whether by contract or otherwise, or (ii) ownership of fifty percent (50%) or more of the outstanding shares, or (iii) beneficial ownership of such entity. "You" (or "Your") shall mean an individual or Legal Entity exercising permissions granted by this License. "Source" form shall mean the preferred form for making modifications, including but not limited to software source code, documentation source, and configuration files. "Object" form shall mean any form resulting from mechanical transformation or translation of a Source form, including but not limited to compiled object code, generated documentation, and conversions to other media types. "Work" shall mean the work of authorship, whether in Source or Object form, made available under the License, as indicated by a copyright notice that is included in or attached to the work (an example is provided in the Appendix below). "Derivative Works" shall mean any work, whether in Source or Object form, that is based on (or derived from) the Work and for which the editorial revisions, annotations, elaborations, or other modifications represent, as a whole, an original work of authorship. For the purposes of this License, Derivative Works shall not include works that remain separable from, or merely link (or bind by name) to the interfaces of, the Work and Derivative Works thereof. "Contribution" shall mean any work of authorship, including the original version of the Work and any modifications or additions to that Work or Derivative Works thereof, that is intentionally submitted to Licensor for inclusion in the Work by the copyright owner or by an individual or Legal Entity authorized to submit on behalf of the copyright owner. For the purposes of this definition, "submitted" means any form of electronic, verbal, or written communication sent to the Licensor or its representatives, including but not limited to communication on electronic mailing lists, source code control systems, and issue tracking systems that are managed by, or on behalf of, the Licensor for the purpose of discussing and improving the Work, but excluding communication that is conspicuously marked or otherwise designated in writing by the copyright owner as "Not a Contribution." "Contributor" shall mean Licensor and any individual or Legal Entity on behalf of whom a Contribution has been received by Licensor and subsequently incorporated within the Work. 2. Grant of Copyright License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable copyright license to reproduce, prepare Derivative Works of, publicly display, publicly perform, sublicense, and distribute the Work and such Derivative Works in Source or Object form. 3. Grant of Patent License. Subject to the terms and conditions of this License, each Contributor hereby grants to You a perpetual, worldwide, non-exclusive, no-charge, royalty-free, irrevocable (except as stated in this section) patent license to make, have made, use, offer to sell, sell, import, and otherwise transfer the Work, where such license applies only to those patent claims licensable by such Contributor that are necessarily infringed by their Contribution(s) alone or by combination of their Contribution(s) with the Work to which such Contribution(s) was submitted. If You institute patent litigation against any entity (including a cross-claim or counterclaim in a lawsuit) alleging that the Work or a Contribution incorporated within the Work constitutes direct or contributory patent infringement, then any patent licenses granted to You under this License for that Work shall terminate as of the date such litigation is filed. 4. Redistribution. You may reproduce and distribute copies of the Work or Derivative Works thereof in any medium, with or without modifications, and in Source or Object form, provided that You meet the following conditions: (a) You must give any other recipients of the Work or Derivative Works a copy of this License; and (b) You must cause any modified files to carry prominent notices stating that You changed the files; and (c) You must retain, in the Source form of any Derivative Works that You distribute, all copyright, patent, trademark, and attribution notices from the Source form of the Work, excluding those notices that do not pertain to any part of the Derivative Works; and (d) If the Work includes a "NOTICE" text file as part of its distribution, then any Derivative Works that You distribute must include a readable copy of the attribution notices contained within such NOTICE file, excluding those notices that do not pertain to any part of the Derivative Works, in at least one of the following places: within a NOTICE text file distributed as part of the Derivative Works; within the Source form or documentation, if provided along with the Derivative Works; or, within a display generated by the Derivative Works, if and wherever such third-party notices normally appear. The contents of the NOTICE file are for informational purposes only and do not modify the License. You may add Your own attribution notices within Derivative Works that You distribute, alongside or as an addendum to the NOTICE text from the Work, provided that such additional attribution notices cannot be construed as modifying the License. You may add Your own copyright statement to Your modifications and may provide additional or different license terms and conditions for use, reproduction, or distribution of Your modifications, or for any such Derivative Works as a whole, provided Your use, reproduction, and distribution of the Work otherwise complies with the conditions stated in this License. 5. Submission of Contributions. Unless You explicitly state otherwise, any Contribution intentionally submitted for inclusion in the Work by You to the Licensor shall be under the terms and conditions of this License, without any additional terms or conditions. Notwithstanding the above, nothing herein shall supersede or modify the terms of any separate license agreement you may have executed with Licensor regarding such Contributions. 6. Trademarks. This License does not grant permission to use the trade names, trademarks, service marks, or product names of the Licensor, except as required for reasonable and customary use in describing the origin of the Work and reproducing the content of the NOTICE file. 7. Disclaimer of Warranty. Unless required by applicable law or agreed to in writing, Licensor provides the Work (and each Contributor provides its Contributions) on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied, including, without limitation, any warranties or conditions of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A PARTICULAR PURPOSE. You are solely responsible for determining the appropriateness of using or redistributing the Work and assume any risks associated with Your exercise of permissions under this License. 8. Limitation of Liability. In no event and under no legal theory, whether in tort (including negligence), contract, or otherwise, unless required by applicable law (such as deliberate and grossly negligent acts) or agreed to in writing, shall any Contributor be liable to You for damages, including any direct, indirect, special, incidental, or consequential damages of any character arising as a result of this License or out of the use or inability to use the Work (including but not limited to damages for loss of goodwill, work stoppage, computer failure or malfunction, or any and all other commercial damages or losses), even if such Contributor has been advised of the possibility of such damages. 9. Accepting Warranty or Additional Liability. While redistributing the Work or Derivative Works thereof, You may choose to offer, and charge a fee for, acceptance of support, warranty, indemnity, or other liability obligations and/or rights consistent with this License. However, in accepting such obligations, You may act only on Your own behalf and on Your sole responsibility, not on behalf of any other Contributor, and only if You agree to indemnify, defend, and hold each Contributor harmless for any liability incurred by, or claims asserted against, such Contributor by reason of your accepting any such warranty or additional liability. END OF TERMS AND CONDITIONS APPENDIX: How to apply the Apache License to your work. To apply the Apache License to your work, attach the following boilerplate notice, with the fields enclosed by brackets "{}" replaced with your own identifying information. (Don't include the brackets!) The text should be enclosed in the appropriate comment syntax for the file format. We also recommend that a file or class name and description of purpose be included on the same "printed page" as the copyright notice for easier identification within third-party archives. Copyright {yyyy} {name of copyright owner} Licensed under the Apache License, Version 2.0 (the "License"); you may not use this file except in compliance with the License. You may obtain a copy of the License at http://www.apache.org/licenses/LICENSE-2.0 Unless required by applicable law or agreed to in writing, software distributed under the License is distributed on an "AS IS" BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. See the License for the specific language governing permissions and limitations under the License. golang-github-ebitengine-purego-0.9.1/README.md000066400000000000000000000104231512124053000211260ustar00rootroot00000000000000# purego [![Go Reference](https://pkg.go.dev/badge/github.com/ebitengine/purego?GOOS=darwin.svg)](https://pkg.go.dev/github.com/ebitengine/purego?GOOS=darwin) A library for calling C functions from Go without Cgo. > This is beta software so expect bugs and potentially API breaking changes > but each release will be tagged to avoid breaking people's code. > Bug reports are encouraged. ## Motivation The [Ebitengine](https://github.com/hajimehoshi/ebiten) game engine was ported to use only Go on Windows. This enabled cross-compiling to Windows from any other operating system simply by setting `GOOS=windows`. The purego project was born to bring that same vision to the other platforms supported by Ebitengine. ## Benefits - **Simple Cross-Compilation**: No C means you can build for other platforms easily without a C compiler. - **Faster Compilation**: Efficiently cache your entirely Go builds. - **Smaller Binaries**: Using Cgo generates a C wrapper function for each C function called. Purego doesn't! - **Dynamic Linking**: Load symbols at runtime and use it as a plugin system. - **Foreign Function Interface**: Call into other languages that are compiled into shared objects. - **Cgo Fallback**: Works even with CGO_ENABLED=1 so incremental porting is possible. This also means unsupported GOARCHs (freebsd/riscv64, linux/mips, etc.) will still work except for float arguments and return values. ## Supported Platforms ### Tier 1 Tier 1 platforms are the primary targets officially supported by PureGo. When a new version of PureGo is released, any critical bugs found on Tier 1 platforms are treated as release blockers. The release will be postponed until such issues are resolved. - **Android**: amd64, arm64 - **iOS**: amd64, arm64 - **Linux**: amd64, arm64 - **macOS**: amd64, arm64 - **Windows**: amd64, arm64 ### Tier 2 Tier 2 platforms are supported by PureGo on a best-effort basis. Critical bugs on Tier 2 platforms do not block new PureGo releases. However, fixes contributed by external contributors are very welcome and encouraged. - **Android**: 386, arm - **FreeBSD**: amd64, arm64 - **Linux**: 386, arm, loong64 - **Windows**: 386*, arm* `*` These architectures only support `SyscallN` and `NewCallback` ## Example The example below only showcases purego use for macOS and Linux. The other platforms require special handling which can be seen in the complete example at [examples/libc](https://github.com/ebitengine/purego/tree/main/examples/libc) which supports FreeBSD and Windows. ```go package main import ( "fmt" "runtime" "github.com/ebitengine/purego" ) func getSystemLibrary() string { switch runtime.GOOS { case "darwin": return "/usr/lib/libSystem.B.dylib" case "linux": return "libc.so.6" default: panic(fmt.Errorf("GOOS=%s is not supported", runtime.GOOS)) } } func main() { libc, err := purego.Dlopen(getSystemLibrary(), purego.RTLD_NOW|purego.RTLD_GLOBAL) if err != nil { panic(err) } var puts func(string) purego.RegisterLibFunc(&puts, libc, "puts") puts("Calling C from Go without Cgo!") } ``` Then to run: `CGO_ENABLED=0 go run main.go` ## Questions If you have questions about how to incorporate purego in your project or want to discuss how it works join the [Discord](https://discord.gg/HzGZVD6BkY)! ### External Code Purego uses code that originates from the Go runtime. These files are under the BSD-3 License that can be found [in the Go Source](https://github.com/golang/go/blob/master/LICENSE). This is a list of the copied files: * `abi_*.h` from package `runtime/cgo` * `wincallback.go` from package `runtime` * `zcallback_darwin_*.s` from package `runtime` * `internal/fakecgo/abi_*.h` from package `runtime/cgo` * `internal/fakecgo/asm_GOARCH.s` from package `runtime/cgo` * `internal/fakecgo/callbacks.go` from package `runtime/cgo` * `internal/fakecgo/go_GOOS_GOARCH.go` from package `runtime/cgo` * `internal/fakecgo/iscgo.go` from package `runtime/cgo` * `internal/fakecgo/setenv.go` from package `runtime/cgo` * `internal/fakecgo/freebsd.go` from package `runtime/cgo` * `internal/fakecgo/netbsd.go` from package `runtime/cgo` The files `abi_*.h` and `internal/fakecgo/abi_*.h` are the same because Bazel does not support cross-package use of `#include` so we need each one once per package. (cf. [issue](https://github.com/bazelbuild/rules_go/issues/3636)) golang-github-ebitengine-purego-0.9.1/abi_amd64.h000066400000000000000000000053531512124053000215540ustar00rootroot00000000000000// Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Macros for transitioning from the host ABI to Go ABI0. // // These save the frame pointer, so in general, functions that use // these should have zero frame size to suppress the automatic frame // pointer, though it's harmless to not do this. #ifdef GOOS_windows // REGS_HOST_TO_ABI0_STACK is the stack bytes used by // PUSH_REGS_HOST_TO_ABI0. #define REGS_HOST_TO_ABI0_STACK (28*8 + 8) // PUSH_REGS_HOST_TO_ABI0 prepares for transitioning from // the host ABI to Go ABI0 code. It saves all registers that are // callee-save in the host ABI and caller-save in Go ABI0 and prepares // for entry to Go. // // Save DI SI BP BX R12 R13 R14 R15 X6-X15 registers and the DF flag. // Clear the DF flag for the Go ABI. // MXCSR matches the Go ABI, so we don't have to set that, // and Go doesn't modify it, so we don't have to save it. #define PUSH_REGS_HOST_TO_ABI0() \ PUSHFQ \ CLD \ ADJSP $(REGS_HOST_TO_ABI0_STACK - 8) \ MOVQ DI, (0*0)(SP) \ MOVQ SI, (1*8)(SP) \ MOVQ BP, (2*8)(SP) \ MOVQ BX, (3*8)(SP) \ MOVQ R12, (4*8)(SP) \ MOVQ R13, (5*8)(SP) \ MOVQ R14, (6*8)(SP) \ MOVQ R15, (7*8)(SP) \ MOVUPS X6, (8*8)(SP) \ MOVUPS X7, (10*8)(SP) \ MOVUPS X8, (12*8)(SP) \ MOVUPS X9, (14*8)(SP) \ MOVUPS X10, (16*8)(SP) \ MOVUPS X11, (18*8)(SP) \ MOVUPS X12, (20*8)(SP) \ MOVUPS X13, (22*8)(SP) \ MOVUPS X14, (24*8)(SP) \ MOVUPS X15, (26*8)(SP) #define POP_REGS_HOST_TO_ABI0() \ MOVQ (0*0)(SP), DI \ MOVQ (1*8)(SP), SI \ MOVQ (2*8)(SP), BP \ MOVQ (3*8)(SP), BX \ MOVQ (4*8)(SP), R12 \ MOVQ (5*8)(SP), R13 \ MOVQ (6*8)(SP), R14 \ MOVQ (7*8)(SP), R15 \ MOVUPS (8*8)(SP), X6 \ MOVUPS (10*8)(SP), X7 \ MOVUPS (12*8)(SP), X8 \ MOVUPS (14*8)(SP), X9 \ MOVUPS (16*8)(SP), X10 \ MOVUPS (18*8)(SP), X11 \ MOVUPS (20*8)(SP), X12 \ MOVUPS (22*8)(SP), X13 \ MOVUPS (24*8)(SP), X14 \ MOVUPS (26*8)(SP), X15 \ ADJSP $-(REGS_HOST_TO_ABI0_STACK - 8) \ POPFQ #else // SysV ABI #define REGS_HOST_TO_ABI0_STACK (6*8) // SysV MXCSR matches the Go ABI, so we don't have to set that, // and Go doesn't modify it, so we don't have to save it. // Both SysV and Go require DF to be cleared, so that's already clear. // The SysV and Go frame pointer conventions are compatible. #define PUSH_REGS_HOST_TO_ABI0() \ ADJSP $(REGS_HOST_TO_ABI0_STACK) \ MOVQ BP, (5*8)(SP) \ LEAQ (5*8)(SP), BP \ MOVQ BX, (0*8)(SP) \ MOVQ R12, (1*8)(SP) \ MOVQ R13, (2*8)(SP) \ MOVQ R14, (3*8)(SP) \ MOVQ R15, (4*8)(SP) #define POP_REGS_HOST_TO_ABI0() \ MOVQ (0*8)(SP), BX \ MOVQ (1*8)(SP), R12 \ MOVQ (2*8)(SP), R13 \ MOVQ (3*8)(SP), R14 \ MOVQ (4*8)(SP), R15 \ MOVQ (5*8)(SP), BP \ ADJSP $-(REGS_HOST_TO_ABI0_STACK) #endif golang-github-ebitengine-purego-0.9.1/abi_arm64.h000066400000000000000000000027671512124053000216000ustar00rootroot00000000000000// Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Macros for transitioning from the host ABI to Go ABI0. // // These macros save and restore the callee-saved registers // from the stack, but they don't adjust stack pointer, so // the user should prepare stack space in advance. // SAVE_R19_TO_R28(offset) saves R19 ~ R28 to the stack space // of ((offset)+0*8)(RSP) ~ ((offset)+9*8)(RSP). // // SAVE_F8_TO_F15(offset) saves F8 ~ F15 to the stack space // of ((offset)+0*8)(RSP) ~ ((offset)+7*8)(RSP). // // R29 is not saved because Go will save and restore it. #define SAVE_R19_TO_R28(offset) \ STP (R19, R20), ((offset)+0*8)(RSP) \ STP (R21, R22), ((offset)+2*8)(RSP) \ STP (R23, R24), ((offset)+4*8)(RSP) \ STP (R25, R26), ((offset)+6*8)(RSP) \ STP (R27, g), ((offset)+8*8)(RSP) #define RESTORE_R19_TO_R28(offset) \ LDP ((offset)+0*8)(RSP), (R19, R20) \ LDP ((offset)+2*8)(RSP), (R21, R22) \ LDP ((offset)+4*8)(RSP), (R23, R24) \ LDP ((offset)+6*8)(RSP), (R25, R26) \ LDP ((offset)+8*8)(RSP), (R27, g) /* R28 */ #define SAVE_F8_TO_F15(offset) \ FSTPD (F8, F9), ((offset)+0*8)(RSP) \ FSTPD (F10, F11), ((offset)+2*8)(RSP) \ FSTPD (F12, F13), ((offset)+4*8)(RSP) \ FSTPD (F14, F15), ((offset)+6*8)(RSP) #define RESTORE_F8_TO_F15(offset) \ FLDPD ((offset)+0*8)(RSP), (F8, F9) \ FLDPD ((offset)+2*8)(RSP), (F10, F11) \ FLDPD ((offset)+4*8)(RSP), (F12, F13) \ FLDPD ((offset)+6*8)(RSP), (F14, F15) golang-github-ebitengine-purego-0.9.1/abi_loong64.h000066400000000000000000000037121512124053000221260ustar00rootroot00000000000000// Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Macros for transitioning from the host ABI to Go ABI0. // // These macros save and restore the callee-saved registers // from the stack, but they don't adjust stack pointer, so // the user should prepare stack space in advance. // SAVE_R22_TO_R31(offset) saves R22 ~ R31 to the stack space // of ((offset)+0*8)(R3) ~ ((offset)+9*8)(R3). // // SAVE_F24_TO_F31(offset) saves F24 ~ F31 to the stack space // of ((offset)+0*8)(R3) ~ ((offset)+7*8)(R3). // // Note: g is R22 #define SAVE_R22_TO_R31(offset) \ MOVV g, ((offset)+(0*8))(R3) \ MOVV R23, ((offset)+(1*8))(R3) \ MOVV R24, ((offset)+(2*8))(R3) \ MOVV R25, ((offset)+(3*8))(R3) \ MOVV R26, ((offset)+(4*8))(R3) \ MOVV R27, ((offset)+(5*8))(R3) \ MOVV R28, ((offset)+(6*8))(R3) \ MOVV R29, ((offset)+(7*8))(R3) \ MOVV R30, ((offset)+(8*8))(R3) \ MOVV R31, ((offset)+(9*8))(R3) #define SAVE_F24_TO_F31(offset) \ MOVD F24, ((offset)+(0*8))(R3) \ MOVD F25, ((offset)+(1*8))(R3) \ MOVD F26, ((offset)+(2*8))(R3) \ MOVD F27, ((offset)+(3*8))(R3) \ MOVD F28, ((offset)+(4*8))(R3) \ MOVD F29, ((offset)+(5*8))(R3) \ MOVD F30, ((offset)+(6*8))(R3) \ MOVD F31, ((offset)+(7*8))(R3) #define RESTORE_R22_TO_R31(offset) \ MOVV ((offset)+(0*8))(R3), g \ MOVV ((offset)+(1*8))(R3), R23 \ MOVV ((offset)+(2*8))(R3), R24 \ MOVV ((offset)+(3*8))(R3), R25 \ MOVV ((offset)+(4*8))(R3), R26 \ MOVV ((offset)+(5*8))(R3), R27 \ MOVV ((offset)+(6*8))(R3), R28 \ MOVV ((offset)+(7*8))(R3), R29 \ MOVV ((offset)+(8*8))(R3), R30 \ MOVV ((offset)+(9*8))(R3), R31 #define RESTORE_F24_TO_F31(offset) \ MOVD ((offset)+(0*8))(R3), F24 \ MOVD ((offset)+(1*8))(R3), F25 \ MOVD ((offset)+(2*8))(R3), F26 \ MOVD ((offset)+(3*8))(R3), F27 \ MOVD ((offset)+(4*8))(R3), F28 \ MOVD ((offset)+(5*8))(R3), F29 \ MOVD ((offset)+(6*8))(R3), F30 \ MOVD ((offset)+(7*8))(R3), F31 golang-github-ebitengine-purego-0.9.1/callback_test.go000066400000000000000000000125561512124053000230020ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors //go:build darwin || (linux && (amd64 || arm64 || loong64)) package purego_test import ( "fmt" "os" "path/filepath" "testing" "unsafe" "github.com/ebitengine/purego" ) // TestCallGoFromSharedLib is a test that checks for stack corruption on arm64 // when C calls Go code from a non-Go thread in a dynamically loaded share library. func TestCallGoFromSharedLib(t *testing.T) { libFileName := filepath.Join(t.TempDir(), "libcbtest.so") t.Logf("Build %v", libFileName) if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "libcbtest", "callback_test.c")); err != nil { t.Fatal(err) } defer os.Remove(libFileName) lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL) if err != nil { t.Fatalf("Dlopen(%q) failed: %v", libFileName, err) } var callCallback func(p uintptr, s string) int purego.RegisterLibFunc(&callCallback, lib, "callCallback") goFunc := func(cstr *byte, n int) int { s := string(unsafe.Slice(cstr, n)) t.Logf("FROM Go: %s\n", s) return 1 } const want = 10101 cb := purego.NewCallback(goFunc) for i := 0; i < 10; i++ { got := callCallback(cb, "a test string") if got != want { t.Fatalf("%d: callCallback() got %v want %v", i, got, want) } } } func TestNewCallbackFloat64(t *testing.T) { // This tests the maximum number of arguments a function to NewCallback can take const ( expectCbTotal = -3 expectedCbTotalF = float64(36) ) var cbTotal int var cbTotalF float64 imp := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int, f1, f2, f3, f4, f5, f6, f7, f8 float64, ) { cbTotal = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 cbTotalF = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 }) var fn func(a1, a2, a3, a4, a5, a6, a7, a8, a9 int, f1, f2, f3, f4, f5, f6, f7, f8 float64) purego.RegisterFunc(&fn, imp) fn(1, 2, -3, 4, -5, 6, -7, 8, -9, 1, 2, 3, 4, 5, 6, 7, 8) if cbTotal != expectCbTotal { t.Errorf("cbTotal not correct got %d but wanted %d", cbTotal, expectCbTotal) } if cbTotalF != expectedCbTotalF { t.Errorf("cbTotalF not correct got %f but wanted %f", cbTotalF, expectedCbTotalF) } } func TestNewCallbackFloat64AndIntMix(t *testing.T) { // This tests interleaving float and integer arguments to NewCallback const ( expectCbTotal = 54.75 ) var cbTotal float64 imp := purego.NewCallback(func(a1, a2 float64, a3, a4, a5 int, a6, a7, a8 float64, a9 int) { cbTotal = a1 + a2 + float64(a3) + float64(a4) + float64(a5) + a6 + a7 + a8 + float64(a9) }) var fn func(a1, a2 float64, a3, a4, a5 int, a6, a7, a8 float64, a9 int) purego.RegisterFunc(&fn, imp) fn(1.25, 3.25, 4, 5, 6, 7.5, 8.25, 9.5, 10) if cbTotal != expectCbTotal { t.Errorf("cbTotal not correct got %f but wanted %f", cbTotal, expectCbTotal) } } func TestNewCallbackFloat32(t *testing.T) { // This tests the maximum number of float32 arguments a function to NewCallback can take const ( expectCbTotal = 6 expectedCbTotalF = float32(45) ) var cbTotal int var cbTotalF float32 imp := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8 int, f1, f2, f3, f4, f5, f6, f7, f8, f9 float32, ) { cbTotal = a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 cbTotalF = f1 + f2 + f3 + f4 + f5 + f6 + f7 + f8 + f9 }) var fn func(a1, a2, a3, a4, a5, a6, a7, a8 int, f1, f2, f3, f4, f5, f6, f7, f8, f9 float32) purego.RegisterFunc(&fn, imp) fn(1, 2, -3, 4, -5, 6, -7, 8, 1, 2, 3, 4, 5, 6, 7, 8, 9) if cbTotal != expectCbTotal { t.Errorf("cbTotal not correct got %d but wanted %d", cbTotal, expectCbTotal) } if cbTotalF != expectedCbTotalF { t.Errorf("cbTotalF not correct got %f but wanted %f", cbTotalF, expectedCbTotalF) } } func TestNewCallbackFloat32AndFloat64(t *testing.T) { // This tests that calling a function with a mix of float32 and float64 arguments works const ( expectedCbTotalF32 = float32(72) expectedCbTotalF64 = float64(48) ) var cbTotalF32 float32 var cbTotalF64 float64 imp := purego.NewCallback(func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32, f10, f11, f12 float64, f13, f14, f15 float32) { cbTotalF32 = f1 + f2 + f3 + f7 + f8 + f9 + f13 + f14 + f15 cbTotalF64 = f4 + f5 + f6 + f10 + f11 + f12 }) var fn func(f1, f2, f3 float32, f4, f5, f6 float64, f7, f8, f9 float32, f10, f11, f12 float64, f13, f14, f15 float32) purego.RegisterFunc(&fn, imp) fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) if cbTotalF32 != expectedCbTotalF32 { t.Errorf("cbTotalF32 not correct got %f but wanted %f", cbTotalF32, expectedCbTotalF32) } if cbTotalF64 != expectedCbTotalF64 { t.Errorf("cbTotalF64 not correct got %f but wanted %f", cbTotalF64, expectedCbTotalF64) } } func ExampleNewCallback() { cb := purego.NewCallback(func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 int) int { fmt.Println(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) return a1 + a2 + a3 + a4 + a5 + a6 + a7 + a8 + a9 + a10 + a11 + a12 + a13 + a14 + a15 }) var fn func(a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 int) int purego.RegisterFunc(&fn, cb) ret := fn(1, 2, 3, 4, 5, 6, 7, 8, 9, 10, 11, 12, 13, 14, 15) fmt.Println(ret) // Output: 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 // 120 } func ExampleNewCallback_cdecl() { fn := func(_ purego.CDecl, a int) { fmt.Println(a) } cb := purego.NewCallback(fn) purego.SyscallN(cb, 83) // Output: 83 } golang-github-ebitengine-purego-0.9.1/cgo.go000066400000000000000000000014251512124053000207500ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build cgo && (darwin || freebsd || linux || netbsd) package purego // if CGO_ENABLED=1 import the Cgo runtime to ensure that it is set up properly. // This is required since some frameworks need TLS setup the C way which Go doesn't do. // We currently don't support ios in fakecgo mode so force Cgo or fail // Even if CGO_ENABLED=1 the Cgo runtime is not imported unless `import "C"` is used. // which will import this package automatically. Normally this isn't an issue since it // usually isn't possible to call into C without using that import. However, with purego // it is since we don't use `import "C"`! import ( _ "runtime/cgo" _ "github.com/ebitengine/purego/internal/cgo" ) golang-github-ebitengine-purego-0.9.1/dlerror.go000066400000000000000000000006321512124053000216500ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors //go:build darwin || freebsd || linux || netbsd package purego // Dlerror represents an error value returned from Dlopen, Dlsym, or Dlclose. // // This type is not available on Windows as there is no counterpart to it on Windows. type Dlerror struct { s string } func (e Dlerror) Error() string { return e.s } golang-github-ebitengine-purego-0.9.1/dlfcn.go000066400000000000000000000067111512124053000212710ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build (darwin || freebsd || linux || netbsd) && !android && !faketime package purego import ( "unsafe" ) // Unix Specification for dlfcn.h: https://pubs.opengroup.org/onlinepubs/7908799/xsh/dlfcn.h.html var ( fnDlopen func(path string, mode int) uintptr fnDlsym func(handle uintptr, name string) uintptr fnDlerror func() string fnDlclose func(handle uintptr) bool ) func init() { RegisterFunc(&fnDlopen, dlopenABI0) RegisterFunc(&fnDlsym, dlsymABI0) RegisterFunc(&fnDlerror, dlerrorABI0) RegisterFunc(&fnDlclose, dlcloseABI0) } // Dlopen examines the dynamic library or bundle file specified by path. If the file is compatible // with the current process and has not already been loaded into the // current process, it is loaded and linked. After being linked, if it contains // any initializer functions, they are called, before Dlopen // returns. It returns a handle that can be used with Dlsym and Dlclose. // A second call to Dlopen with the same path will return the same handle, but the internal // reference count for the handle will be incremented. Therefore, all // Dlopen calls should be balanced with a Dlclose call. // // This function is not available on Windows. // Use [golang.org/x/sys/windows.LoadLibrary], [golang.org/x/sys/windows.LoadLibraryEx], // [golang.org/x/sys/windows.NewLazyDLL], or [golang.org/x/sys/windows.NewLazySystemDLL] for Windows instead. func Dlopen(path string, mode int) (uintptr, error) { u := fnDlopen(path, mode) if u == 0 { return 0, Dlerror{fnDlerror()} } return u, nil } // Dlsym takes a "handle" of a dynamic library returned by Dlopen and the symbol name. // It returns the address where that symbol is loaded into memory. If the symbol is not found, // in the specified library or any of the libraries that were automatically loaded by Dlopen // when that library was loaded, Dlsym returns zero. // // This function is not available on Windows. // Use [golang.org/x/sys/windows.GetProcAddress] for Windows instead. func Dlsym(handle uintptr, name string) (uintptr, error) { u := fnDlsym(handle, name) if u == 0 { return 0, Dlerror{fnDlerror()} } return u, nil } // Dlclose decrements the reference count on the dynamic library handle. // If the reference count drops to zero and no other loaded libraries // use symbols in it, then the dynamic library is unloaded. // // This function is not available on Windows. // Use [golang.org/x/sys/windows.FreeLibrary] for Windows instead. func Dlclose(handle uintptr) error { if fnDlclose(handle) { return Dlerror{fnDlerror()} } return nil } func loadSymbol(handle uintptr, name string) (uintptr, error) { return Dlsym(handle, name) } // these functions exist in dlfcn_stubs.s and are calling C functions linked to in dlfcn_GOOS.go // the indirection is necessary because a function is actually a pointer to the pointer to the code. // sadly, I do not know of anyway to remove the assembly stubs entirely because //go:linkname doesn't // appear to work if you link directly to the C function on darwin arm64. //go:linkname dlopen dlopen var dlopen uint8 var dlopenABI0 = uintptr(unsafe.Pointer(&dlopen)) //go:linkname dlsym dlsym var dlsym uint8 var dlsymABI0 = uintptr(unsafe.Pointer(&dlsym)) //go:linkname dlclose dlclose var dlclose uint8 var dlcloseABI0 = uintptr(unsafe.Pointer(&dlclose)) //go:linkname dlerror dlerror var dlerror uint8 var dlerrorABI0 = uintptr(unsafe.Pointer(&dlerror)) golang-github-ebitengine-purego-0.9.1/dlfcn_android.go000066400000000000000000000015661512124053000227740ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors package purego import "github.com/ebitengine/purego/internal/cgo" // Source for constants: https://android.googlesource.com/platform/bionic/+/refs/heads/main/libc/include/dlfcn.h const ( is64bit = 1 << (^uintptr(0) >> 63) / 2 is32bit = 1 - is64bit RTLD_DEFAULT = is32bit * 0xffffffff RTLD_LAZY = 0x00000001 RTLD_NOW = is64bit * 0x00000002 RTLD_LOCAL = 0x00000000 RTLD_GLOBAL = is64bit*0x00100 | is32bit*0x00000002 ) func Dlopen(path string, mode int) (uintptr, error) { return cgo.Dlopen(path, mode) } func Dlsym(handle uintptr, name string) (uintptr, error) { return cgo.Dlsym(handle, name) } func Dlclose(handle uintptr) error { return cgo.Dlclose(handle) } func loadSymbol(handle uintptr, name string) (uintptr, error) { return Dlsym(handle, name) } golang-github-ebitengine-purego-0.9.1/dlfcn_darwin.go000066400000000000000000000017371512124053000226400ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors package purego // Source for constants: https://opensource.apple.com/source/dyld/dyld-360.14/include/dlfcn.h.auto.html const ( RTLD_DEFAULT = 1<<64 - 2 // Pseudo-handle for dlsym so search for any loaded symbol RTLD_LAZY = 0x1 // Relocations are performed at an implementation-dependent time. RTLD_NOW = 0x2 // Relocations are performed when the object is loaded. RTLD_LOCAL = 0x4 // All symbols are not made available for relocation processing by other modules. RTLD_GLOBAL = 0x8 // All symbols are available for relocation processing of other modules. ) //go:cgo_import_dynamic purego_dlopen dlopen "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_dlsym dlsym "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_dlerror dlerror "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_dlclose dlclose "/usr/lib/libSystem.B.dylib" golang-github-ebitengine-purego-0.9.1/dlfcn_freebsd.go000066400000000000000000000014331512124053000227570ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors package purego // Constants as defined in https://github.com/freebsd/freebsd-src/blob/main/include/dlfcn.h const ( intSize = 32 << (^uint(0) >> 63) // 32 or 64 RTLD_DEFAULT = 1<> 63) // 32 or 64 RTLD_DEFAULT = 1< // @property (readwrite) bar int // @end class, err := objc.RegisterClass( "BarObject", objc.GetClass("NSObject"), []*objc.Protocol{ objc.GetProtocol("NSDelegateWindow"), }, []objc.FieldDef{ { Name: "bar", Type: reflect.TypeOf(int(0)), Attribute: objc.ReadWrite, }, }, []objc.MethodDef{ { Cmd: sel_init, Fn: BarInit, }, }, ) if err != nil { panic(err) } object := objc.ID(class).Send(sel_new) object.Send(sel_setBar, 123) bar := int(object.Send(sel_bar)) fmt.Println(bar) // Output: 123 } golang-github-ebitengine-purego-0.9.1/examples/protocol-dumper/000077500000000000000000000000001512124053000246205ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/examples/protocol-dumper/main_darwin.go000066400000000000000000000114141512124053000274400ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors package main // #cgo CFLAGS: -x objective-c // #cgo LDFLAGS: -framework AppKit // // #import // // __attribute__((used)) // static void __force_protocol_load() { // id o = NULL; // o = @protocol(NSAccessibility); // o = @protocol(NSApplicationDelegate); // } import "C" import ( "fmt" "io" "os" "strconv" "strings" "text/template" "github.com/ebitengine/purego/objc" ) var protocols = []string{ "NSAccessibility", "NSApplicationDelegate", } type ProtocolImpl struct { Name string RequiredInstanceMethods []objc.MethodDescription RequiredClassMethods []objc.MethodDescription OptionalInstanceMethods []objc.MethodDescription OptionalClassMethods []objc.MethodDescription AdoptedProtocols []*objc.Protocol RequiredInstanceProperties []objc.Property RequiredClassProperties []objc.Property OptionalInstanceProperties []objc.Property OptionalClassProperties []objc.Property } func readProtocols(names []string) (imps []ProtocolImpl, err error) { for _, name := range names { p := objc.GetProtocol(name) if p == nil { return nil, fmt.Errorf("protocol '%s' does not exist", name) } imp := ProtocolImpl{} imp.Name = name imp.RequiredInstanceMethods = p.CopyMethodDescriptionList(true, true) imp.RequiredClassMethods = p.CopyMethodDescriptionList(true, false) imp.OptionalInstanceMethods = p.CopyMethodDescriptionList(false, true) imp.OptionalClassMethods = p.CopyMethodDescriptionList(false, false) imp.AdoptedProtocols = p.CopyProtocolList() imp.RequiredInstanceProperties = p.CopyPropertyList(true, true) imp.RequiredClassProperties = p.CopyPropertyList(true, false) imp.OptionalInstanceProperties = p.CopyPropertyList(false, true) imp.OptionalClassProperties = p.CopyPropertyList(false, false) imps = append(imps, imp) } return imps, nil } const templ = `// Code generated by protocol-dumper; DO NOT EDIT. package main import ( "log" "github.com/ebitengine/purego/objc" ) func init() { var p *objc.Protocol {{- range . }} {{- $protocolName := .Name }} if p = objc.AllocateProtocol("{{$protocolName}}"); p != nil { {{- range .RequiredInstanceMethods }} p.AddMethodDescription(objc.RegisterName("{{ .Name }}"), "{{ .Types }}", true, true) {{- end }} {{- range .RequiredClassMethods }} p.AddMethodDescription(objc.RegisterName("{{ .Name }}"), "{{ .Types }}", true, false) {{- end }} {{- range .OptionalInstanceMethods }} p.AddMethodDescription(objc.RegisterName("{{ .Name }}"), "{{ .Types }}", false, true) {{- end }} {{- range .OptionalClassMethods }} p.AddMethodDescription(objc.RegisterName("{{ .Name }}"), "{{ .Types }}", false, false) {{- end }} var adoptedProtocol *objc.Protocol {{- range .AdoptedProtocols }} adoptedProtocol = objc.GetProtocol("{{ .Name }}") if adoptedProtocol == nil { log.Fatalln("protocol '{{ .Name }}' does not exist") } p.AddProtocol(adoptedProtocol) {{- end }} {{- range .RequiredInstanceProperties }} p.AddProperty("{{ .Name }}", {{ attributeToStructString . }}, true, true) {{- end }} {{- range .RequiredClassProperties }} p.AddProperty("{{ .Name }}", {{ attributeToStructString . }}, true, false) {{- end }} {{- range .OptionalInstanceProperties }} p.AddProperty("{{ .Name }}", {{ attributeToStructString . }}, false, true) {{- end }} {{- range .OptionalClassProperties }} p.AddProperty("{{ .Name }}", {{ attributeToStructString . }}, false, false) {{- end }} p.Register() } // Finished protocol: {{$protocolName}} {{- end }} } ` func printProtocols(impls []ProtocolImpl, w io.Writer) error { tmpl, err := template.New("protocol.tmpl").Funcs(template.FuncMap{ "attributeToStructString": attributeToStructString, }).Parse(templ) if err != nil { return err } err = tmpl.Execute(w, impls) if err != nil { return err } return nil } func attributeToStructString(p objc.Property) string { attribs := strings.Split(p.Attributes(), ",") var b strings.Builder b.WriteString("[]objc.PropertyAttribute{") for i, attrib := range attribs { b.WriteString(fmt.Sprintf(`{Name: &[]byte("%s\x00")[0], Value: &[]byte(%s)[0]}`, string(attrib[0]), strconv.Quote(attrib[1:]+"\x00"))) if i != len(attribs)-1 { b.WriteString(", ") } } b.WriteString("}") return b.String() } // This program prints out the Go code to generate the OBJC protocols list. // To use it add the @protocol(name) to the C import section and then add it to the protocols list. // You'll want to run it as amd64 and arm64 since the types are slightly different for each architecture. func main() { var imps []ProtocolImpl var err error if imps, err = readProtocols(protocols); err != nil { panic(err) } if err = printProtocols(imps, os.Stdout); err != nil { panic(err) } } golang-github-ebitengine-purego-0.9.1/examples/window/000077500000000000000000000000001512124053000227745ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/examples/window/main_darwin.go000066400000000000000000000031251512124053000256140ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors package main import ( "runtime" "github.com/ebitengine/purego" "github.com/ebitengine/purego/objc" ) const ( NSApplicationActivationPolicyRegular = 0 NSWindowStyleMaskTitled = 1 << 0 NSBackingStoreBuffered = 2 ) type NSPoint struct { X, Y float64 } type NSSize struct { Width, Height float64 } type NSRect struct { Origin NSPoint Size NSSize } func init() { runtime.LockOSThread() } func main() { if _, err := purego.Dlopen("/System/Library/Frameworks/Cocoa.framework/Cocoa", purego.RTLD_GLOBAL|purego.RTLD_LAZY); err != nil { panic(err) } nsApp := objc.ID(objc.GetClass("NSApplication")).Send(objc.RegisterName("sharedApplication")) nsApp.Send(objc.RegisterName("setActivationPolicy:"), NSApplicationActivationPolicyRegular) wnd := objc.ID(objc.GetClass("NSWindow")).Send(objc.RegisterName("alloc")) wnd = wnd.Send(objc.RegisterName("initWithContentRect:styleMask:backing:defer:"), NSMakeRect(0, 0, 320, 240), NSWindowStyleMaskTitled, NSBackingStoreBuffered, false, ) title := objc.ID(objc.GetClass("NSString")).Send(objc.RegisterName("stringWithUTF8String:"), "My Title") wnd.Send(objc.RegisterName("setTitle:"), title) wnd.Send(objc.RegisterName("makeKeyAndOrderFront:"), objc.ID(0)) wnd.Send(objc.RegisterName("center")) nsApp.Send(objc.RegisterName("activateIgnoringOtherApps:"), true) nsApp.Send(objc.RegisterName("run")) } func NSMakeRect(x, y, width, height float64) NSRect { return NSRect{Origin: NSPoint{x, y}, Size: NSSize{width, height}} } golang-github-ebitengine-purego-0.9.1/examples/window/main_windows.go000066400000000000000000000074771512124053000260400ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors package main import ( "runtime" "syscall" "unsafe" "github.com/ebitengine/purego" ) const ( WS_OVERLAPPEDWINDOW = 0x00000000 | 0x00C00000 | 0x00080000 | 0x00040000 | 0x00020000 | 0x00010000 CW_USEDEFAULT = ^0x7fffffff SW_SHOW = 5 WM_DESTROY = 2 ) type ( ATOM uint16 HANDLE uintptr HINSTANCE HANDLE HICON HANDLE HCURSOR HANDLE HBRUSH HANDLE HWND HANDLE HMENU HANDLE ) type WNDCLASSEX struct { Size uint32 Style uint32 WndProc uintptr ClsExtra int32 WndExtra int32 Instance HINSTANCE Icon HICON Cursor HCURSOR Background HBRUSH MenuName *uint16 ClassName *uint16 IconSm HICON } type RECT struct { Left, Top, Right, Bottom int32 } type POINT struct { X, Y int32 } type MSG struct { Hwnd HWND Message uint32 WParam uintptr LParam uintptr Time uint32 Pt POINT } var ( GetModuleHandle func(modulename *uint16) HINSTANCE RegisterClassEx func(w *WNDCLASSEX) ATOM CreateWindowEx func(exStyle uint, className, windowName *uint16, style uint, x, y, width, height int, parent HWND, menu HMENU, instance HINSTANCE, param unsafe.Pointer) HWND AdjustWindowRect func(rect *RECT, style uint, menu bool) bool ShowWindow func(hwnd HWND, cmdshow int) bool GetMessage func(msg *MSG, hwnd HWND, msgFilterMin, msgFilterMax uint32) int TranslateMessage func(msg *MSG) bool DispatchMessage func(msg *MSG) uintptr DefWindowProc func(hwnd HWND, msg uint32, wParam, lParam uintptr) uintptr PostQuitMessage func(exitCode int) ) func init() { // Use [syscall.NewLazyDLL] here to avoid external dependencies (#270). // For actual use cases, [golang.org/x/sys/windows.NewLazySystemDLL] is recommended. kernel32 := syscall.NewLazyDLL("kernel32.dll").Handle() purego.RegisterLibFunc(&GetModuleHandle, kernel32, "GetModuleHandleW") // Use [syscall.NewLazyDLL] here to avoid external dependencies (#270). // For actual use cases, [golang.org/x/sys/windows.NewLazySystemDLL] is recommended. user32 := syscall.NewLazyDLL("user32.dll").Handle() purego.RegisterLibFunc(&RegisterClassEx, user32, "RegisterClassExW") purego.RegisterLibFunc(&CreateWindowEx, user32, "CreateWindowExW") purego.RegisterLibFunc(&AdjustWindowRect, user32, "AdjustWindowRect") purego.RegisterLibFunc(&ShowWindow, user32, "ShowWindow") purego.RegisterLibFunc(&GetMessage, user32, "GetMessageW") purego.RegisterLibFunc(&TranslateMessage, user32, "TranslateMessage") purego.RegisterLibFunc(&DispatchMessage, user32, "DispatchMessageW") purego.RegisterLibFunc(&DefWindowProc, user32, "DefWindowProcW") purego.RegisterLibFunc(&PostQuitMessage, user32, "PostQuitMessage") runtime.LockOSThread() } func main() { className, err := syscall.UTF16PtrFromString("Sample Window Class") if err != nil { panic(err) } inst := GetModuleHandle(className) wc := WNDCLASSEX{ Size: uint32(unsafe.Sizeof(WNDCLASSEX{})), WndProc: syscall.NewCallback(wndProc), Instance: inst, ClassName: className, } RegisterClassEx(&wc) wr := RECT{ Left: 0, Top: 0, Right: 320, Bottom: 240, } title, err := syscall.UTF16PtrFromString("My Title") if err != nil { panic(err) } AdjustWindowRect(&wr, WS_OVERLAPPEDWINDOW, false) hwnd := CreateWindowEx( 0, className, title, WS_OVERLAPPEDWINDOW, CW_USEDEFAULT, CW_USEDEFAULT, int(wr.Right-wr.Left), int(wr.Bottom-wr.Top), 0, 0, inst, nil, ) if hwnd == 0 { panic(syscall.GetLastError()) } ShowWindow(hwnd, SW_SHOW) var msg MSG for GetMessage(&msg, 0, 0, 0) != 0 { TranslateMessage(&msg) DispatchMessage(&msg) } } func wndProc(hwnd HWND, msg uint32, wparam, lparam uintptr) uintptr { switch msg { case WM_DESTROY: PostQuitMessage(0) } return DefWindowProc(hwnd, msg, wparam, lparam) } golang-github-ebitengine-purego-0.9.1/func.go000066400000000000000000000417621512124053000211430ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build darwin || freebsd || linux || netbsd || windows package purego import ( "fmt" "math" "reflect" "runtime" "strconv" "sync" "unsafe" "github.com/ebitengine/purego/internal/strings" ) var thePool = sync.Pool{New: func() any { return new(syscall15Args) }} // RegisterLibFunc is a wrapper around RegisterFunc that uses the C function returned from Dlsym(handle, name). // It panics if it can't find the name symbol. func RegisterLibFunc(fptr any, handle uintptr, name string) { sym, err := loadSymbol(handle, name) if err != nil { panic(err) } RegisterFunc(fptr, sym) } // RegisterFunc takes a pointer to a Go function representing the calling convention of the C function. // fptr will be set to a function that when called will call the C function given by cfn with the // parameters passed in the correct registers and stack. // // A panic is produced if the type is not a function pointer or if the function returns more than 1 value. // // These conversions describe how a Go type in the fptr will be used to call // the C function. It is important to note that there is no way to verify that fptr // matches the C function. This also holds true for struct types where the padding // needs to be ensured to match that of C; RegisterFunc does not verify this. // // # Type Conversions (Go <=> C) // // string <=> char* // bool <=> _Bool // uintptr <=> uintptr_t // uint <=> uint32_t or uint64_t // uint8 <=> uint8_t // uint16 <=> uint16_t // uint32 <=> uint32_t // uint64 <=> uint64_t // int <=> int32_t or int64_t // int8 <=> int8_t // int16 <=> int16_t // int32 <=> int32_t // int64 <=> int64_t // float32 <=> float // float64 <=> double // struct <=> struct (WIP - darwin only) // func <=> C function // unsafe.Pointer, *T <=> void* // []T => void* // // There is a special case when the last argument of fptr is a variadic interface (or []interface} // it will be expanded into a call to the C function as if it had the arguments in that slice. // This means that using arg ...any is like a cast to the function with the arguments inside arg. // This is not the same as C variadic. // // # Memory // // In general it is not possible for purego to guarantee the lifetimes of objects returned or received from // calling functions using RegisterFunc. For arguments to a C function it is important that the C function doesn't // hold onto a reference to Go memory. This is the same as the [Cgo rules]. // // However, there are some special cases. When passing a string as an argument if the string does not end in a null // terminated byte (\x00) then the string will be copied into memory maintained by purego. The memory is only valid for // that specific call. Therefore, if the C code keeps a reference to that string it may become invalid at some // undefined time. However, if the string does already contain a null-terminated byte then no copy is done. // It is then the responsibility of the caller to ensure the string stays alive as long as it's needed in C memory. // This can be done using runtime.KeepAlive or allocating the string in C memory using malloc. When a C function // returns a null-terminated pointer to char a Go string can be used. Purego will allocate a new string in Go memory // and copy the data over. This string will be garbage collected whenever Go decides it's no longer referenced. // This C created string will not be freed by purego. If the pointer to char is not null-terminated or must continue // to point to C memory (because it's a buffer for example) then use a pointer to byte and then convert that to a slice // using unsafe.Slice. Doing this means that it becomes the responsibility of the caller to care about the lifetime // of the pointer // // # Structs // // Purego can handle the most common structs that have fields of builtin types like int8, uint16, float32, etc. However, // it does not support aligning fields properly. It is therefore the responsibility of the caller to ensure // that all padding is added to the Go struct to match the C one. See `BoolStructFn` in struct_test.go for an example. // // # Example // // All functions below call this C function: // // char *foo(char *str); // // // Let purego convert types // var foo func(s string) string // goString := foo("copied") // // Go will garbage collect this string // // // Manually, handle allocations // var foo2 func(b string) *byte // mustFree := foo2("not copied\x00") // defer free(mustFree) // // [Cgo rules]: https://pkg.go.dev/cmd/cgo#hdr-Go_references_to_C func RegisterFunc(fptr any, cfn uintptr) { fn := reflect.ValueOf(fptr).Elem() ty := fn.Type() if ty.Kind() != reflect.Func { panic("purego: fptr must be a function pointer") } if ty.NumOut() > 1 { panic("purego: function can only return zero or one values") } if cfn == 0 { panic("purego: cfn is nil") } if ty.NumOut() == 1 && (ty.Out(0).Kind() == reflect.Float32 || ty.Out(0).Kind() == reflect.Float64) && runtime.GOARCH != "arm64" && runtime.GOARCH != "amd64" && runtime.GOARCH != "loong64" { panic("purego: float returns are not supported") } { // this code checks how many registers and stack this function will use // to avoid crashing with too many arguments var ints int var floats int var stack int for i := 0; i < ty.NumIn(); i++ { arg := ty.In(i) switch arg.Kind() { case reflect.Func: // This only does preliminary testing to ensure the CDecl argument // is the first argument. Full testing is done when the callback is actually // created in NewCallback. for j := 0; j < arg.NumIn(); j++ { in := arg.In(j) if !in.AssignableTo(reflect.TypeOf(CDecl{})) { continue } if j != 0 { panic("purego: CDecl must be the first argument") } } case reflect.String, reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Ptr, reflect.UnsafePointer, reflect.Slice, reflect.Bool: if ints < numOfIntegerRegisters() { ints++ } else { stack++ } case reflect.Float32, reflect.Float64: const is32bit = unsafe.Sizeof(uintptr(0)) == 4 if is32bit { panic("purego: floats only supported on 64bit platforms") } if floats < numOfFloatRegisters { floats++ } else { stack++ } case reflect.Struct: if runtime.GOOS != "darwin" || (runtime.GOARCH != "amd64" && runtime.GOARCH != "arm64") { panic("purego: struct arguments are only supported on darwin amd64 & arm64") } if arg.Size() == 0 { continue } addInt := func(u uintptr) { ints++ } addFloat := func(u uintptr) { floats++ } addStack := func(u uintptr) { stack++ } _ = addStruct(reflect.New(arg).Elem(), &ints, &floats, &stack, addInt, addFloat, addStack, nil) default: panic("purego: unsupported kind " + arg.Kind().String()) } } if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct { if runtime.GOOS != "darwin" { panic("purego: struct return values only supported on darwin arm64 & amd64") } outType := ty.Out(0) checkStructFieldsSupported(outType) if runtime.GOARCH == "amd64" && outType.Size() > maxRegAllocStructSize { // on amd64 if struct is bigger than 16 bytes allocate the return struct // and pass it in as a hidden first argument. ints++ } } sizeOfStack := maxArgs - numOfIntegerRegisters() if stack > sizeOfStack { panic("purego: too many arguments") } } v := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) { var sysargs [maxArgs]uintptr var floats [numOfFloatRegisters]uintptr var numInts int var numFloats int var numStack int var addStack, addInt, addFloat func(x uintptr) if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" { // Windows arm64 uses the same calling convention as macOS and Linux addStack = func(x uintptr) { sysargs[numOfIntegerRegisters()+numStack] = x numStack++ } addInt = func(x uintptr) { if numInts >= numOfIntegerRegisters() { addStack(x) } else { sysargs[numInts] = x numInts++ } } addFloat = func(x uintptr) { if numFloats < len(floats) { floats[numFloats] = x numFloats++ } else { addStack(x) } } } else { // On Windows amd64 the arguments are passed in the numbered registered. // So the first int is in the first integer register and the first float // is in the second floating register if there is already a first int. // This is in contrast to how macOS and Linux pass arguments which // tries to use as many registers as possible in the calling convention. addStack = func(x uintptr) { sysargs[numStack] = x numStack++ } addInt = addStack addFloat = addStack } var keepAlive []any defer func() { runtime.KeepAlive(keepAlive) runtime.KeepAlive(args) }() var arm64_r8 uintptr if ty.NumOut() == 1 && ty.Out(0).Kind() == reflect.Struct { outType := ty.Out(0) if (runtime.GOARCH == "amd64" || runtime.GOARCH == "loong64") && outType.Size() > maxRegAllocStructSize { val := reflect.New(outType) keepAlive = append(keepAlive, val) addInt(val.Pointer()) } else if runtime.GOARCH == "arm64" && outType.Size() > maxRegAllocStructSize { isAllFloats, numFields := isAllSameFloat(outType) if !isAllFloats || numFields > 4 { val := reflect.New(outType) keepAlive = append(keepAlive, val) arm64_r8 = val.Pointer() } } } for i, v := range args { if variadic, ok := args[i].Interface().([]any); ok { if i != len(args)-1 { panic("purego: can only expand last parameter") } for _, x := range variadic { keepAlive = addValue(reflect.ValueOf(x), keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack) } continue } if runtime.GOARCH == "arm64" && runtime.GOOS == "darwin" && (numInts >= numOfIntegerRegisters() || numFloats >= numOfFloatRegisters) && v.Kind() != reflect.Struct { // hit the stack fields := make([]reflect.StructField, len(args[i:])) for j, val := range args[i:] { if val.Kind() == reflect.String { ptr := strings.CString(val.String()) keepAlive = append(keepAlive, ptr) val = reflect.ValueOf(ptr) args[i+j] = val } fields[j] = reflect.StructField{ Name: "X" + strconv.Itoa(j), Type: val.Type(), } } structType := reflect.StructOf(fields) structInstance := reflect.New(structType).Elem() for j, val := range args[i:] { structInstance.Field(j).Set(val) } placeRegisters(structInstance, addFloat, addInt) break } keepAlive = addValue(v, keepAlive, addInt, addFloat, addStack, &numInts, &numFloats, &numStack) } syscall := thePool.Get().(*syscall15Args) defer thePool.Put(syscall) if runtime.GOARCH == "loong64" { *syscall = syscall15Args{ cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11], sysargs[12], sysargs[13], sysargs[14], floats[0], floats[1], floats[2], floats[3], floats[4], floats[5], floats[6], floats[7], 0, } runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall)) } else if runtime.GOARCH == "arm64" || runtime.GOOS != "windows" { // Use the normal arm64 calling convention even on Windows *syscall = syscall15Args{ cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11], sysargs[12], sysargs[13], sysargs[14], floats[0], floats[1], floats[2], floats[3], floats[4], floats[5], floats[6], floats[7], arm64_r8, } runtime_cgocall(syscall15XABI0, unsafe.Pointer(syscall)) } else { *syscall = syscall15Args{} // This is a fallback for Windows amd64, 386, and arm. Note this may not support floats syscall.a1, syscall.a2, _ = syscall_syscall15X(cfn, sysargs[0], sysargs[1], sysargs[2], sysargs[3], sysargs[4], sysargs[5], sysargs[6], sysargs[7], sysargs[8], sysargs[9], sysargs[10], sysargs[11], sysargs[12], sysargs[13], sysargs[14]) syscall.f1 = syscall.a2 // on amd64 a2 stores the float return. On 32bit platforms floats aren't support } if ty.NumOut() == 0 { return nil } outType := ty.Out(0) v := reflect.New(outType).Elem() switch outType.Kind() { case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: v.SetUint(uint64(syscall.a1)) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: v.SetInt(int64(syscall.a1)) case reflect.Bool: v.SetBool(byte(syscall.a1) != 0) case reflect.UnsafePointer: // We take the address and then dereference it to trick go vet from creating a possible miss-use of unsafe.Pointer v.SetPointer(*(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))) case reflect.Ptr: v = reflect.NewAt(outType, unsafe.Pointer(&syscall.a1)).Elem() case reflect.Func: // wrap this C function in a nicely typed Go function v = reflect.New(outType) RegisterFunc(v.Interface(), syscall.a1) case reflect.String: v.SetString(strings.GoString(syscall.a1)) case reflect.Float32: // NOTE: syscall.r2 is only the floating return value on 64bit platforms. // On 32bit platforms syscall.r2 is the upper part of a 64bit return. v.SetFloat(float64(math.Float32frombits(uint32(syscall.f1)))) case reflect.Float64: // NOTE: syscall.r2 is only the floating return value on 64bit platforms. // On 32bit platforms syscall.r2 is the upper part of a 64bit return. v.SetFloat(math.Float64frombits(uint64(syscall.f1))) case reflect.Struct: v = getStruct(outType, *syscall) default: panic("purego: unsupported return kind: " + outType.Kind().String()) } if len(args) > 0 { // reuse args slice instead of allocating one when possible args[0] = v return args[:1] } else { return []reflect.Value{v} } }) fn.Set(v) } func addValue(v reflect.Value, keepAlive []any, addInt func(x uintptr), addFloat func(x uintptr), addStack func(x uintptr), numInts *int, numFloats *int, numStack *int) []any { switch v.Kind() { case reflect.String: ptr := strings.CString(v.String()) keepAlive = append(keepAlive, ptr) addInt(uintptr(unsafe.Pointer(ptr))) case reflect.Uintptr, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64: addInt(uintptr(v.Uint())) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: addInt(uintptr(v.Int())) case reflect.Ptr, reflect.UnsafePointer, reflect.Slice: // There is no need to keepAlive this pointer separately because it is kept alive in the args variable addInt(v.Pointer()) case reflect.Func: addInt(NewCallback(v.Interface())) case reflect.Bool: if v.Bool() { addInt(1) } else { addInt(0) } case reflect.Float32: addFloat(uintptr(math.Float32bits(float32(v.Float())))) case reflect.Float64: addFloat(uintptr(math.Float64bits(v.Float()))) case reflect.Struct: keepAlive = addStruct(v, numInts, numFloats, numStack, addInt, addFloat, addStack, keepAlive) default: panic("purego: unsupported kind: " + v.Kind().String()) } return keepAlive } // maxRegAllocStructSize is the biggest a struct can be while still fitting in registers. // if it is bigger than this than enough space must be allocated on the heap and then passed into // the function as the first parameter on amd64 or in R8 on arm64. // // If you change this make sure to update it in objc_runtime_darwin.go const maxRegAllocStructSize = 16 func isAllSameFloat(ty reflect.Type) (allFloats bool, numFields int) { allFloats = true root := ty.Field(0).Type for root.Kind() == reflect.Struct { root = root.Field(0).Type } first := root.Kind() if first != reflect.Float32 && first != reflect.Float64 { allFloats = false } for i := 0; i < ty.NumField(); i++ { f := ty.Field(i).Type if f.Kind() == reflect.Struct { var structNumFields int allFloats, structNumFields = isAllSameFloat(f) numFields += structNumFields continue } numFields++ if f.Kind() != first { allFloats = false } } return allFloats, numFields } func checkStructFieldsSupported(ty reflect.Type) { for i := 0; i < ty.NumField(); i++ { f := ty.Field(i).Type if f.Kind() == reflect.Array { f = f.Elem() } else if f.Kind() == reflect.Struct { checkStructFieldsSupported(f) continue } switch f.Kind() { case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Ptr, reflect.UnsafePointer, reflect.Float64, reflect.Float32: default: panic(fmt.Sprintf("purego: struct field type %s is not supported", f)) } } } func roundUpTo8(val uintptr) uintptr { return (val + 7) &^ 7 } func numOfIntegerRegisters() int { switch runtime.GOARCH { case "arm64", "loong64": return 8 case "amd64": return 6 default: // since this platform isn't supported and can therefore only access // integer registers it is fine to return the maxArgs return maxArgs } } golang-github-ebitengine-purego-0.9.1/func_test.go000066400000000000000000000145711512124053000222000ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors package purego_test import ( "errors" "fmt" "os/exec" "path/filepath" "runtime" "strings" "testing" "unsafe" "github.com/ebitengine/purego" "github.com/ebitengine/purego/internal/load" ) func getSystemLibrary() (string, error) { switch runtime.GOOS { case "darwin": return "/usr/lib/libSystem.B.dylib", nil case "freebsd": return "libc.so.7", nil case "linux": return "libc.so.6", nil case "netbsd": return "libc.so", nil case "windows": return "ucrtbase.dll", nil default: return "", fmt.Errorf("GOOS=%s is not supported", runtime.GOOS) } } func TestRegisterFunc(t *testing.T) { library, err := getSystemLibrary() if err != nil { t.Fatalf("couldn't get system library: %s", err) } libc, err := load.OpenLibrary(library) if err != nil { t.Fatalf("failed to dlopen: %s", err) } var puts func(string) purego.RegisterLibFunc(&puts, libc, "puts") puts("Calling C from from Go without Cgo!") } func Test_qsort(t *testing.T) { if runtime.GOARCH != "arm64" && runtime.GOARCH != "amd64" && runtime.GOARCH != "loong64" { t.Skip("Platform doesn't support Floats") return } library, err := getSystemLibrary() if err != nil { t.Fatalf("couldn't get system library: %s", err) } libc, err := load.OpenLibrary(library) if err != nil { t.Fatalf("failed to dlopen: %s", err) } data := []int{88, 56, 100, 2, 25} sorted := []int{2, 25, 56, 88, 100} compare := func(_ purego.CDecl, a, b *int) int { return *a - *b } var qsort func(data []int, nitms uintptr, size uintptr, compar func(_ purego.CDecl, a, b *int) int) purego.RegisterLibFunc(&qsort, libc, "qsort") qsort(data, uintptr(len(data)), unsafe.Sizeof(int(0)), compare) for i := range data { if data[i] != sorted[i] { t.Errorf("got %d wanted %d at %d", data[i], sorted[i], i) } } } func TestRegisterFunc_Floats(t *testing.T) { if runtime.GOARCH != "arm64" && runtime.GOARCH != "amd64" && runtime.GOARCH != "loong64" { t.Skip("Platform doesn't support Floats") return } library, err := getSystemLibrary() if err != nil { t.Fatalf("couldn't get system library: %s", err) } libc, err := load.OpenLibrary(library) if err != nil { t.Fatalf("failed to dlopen: %s", err) } { var strtof func(arg string) float32 purego.RegisterLibFunc(&strtof, libc, "strtof") const ( arg = "2" ) got := strtof(arg) expected := float32(2) if got != expected { t.Errorf("strtof failed. got %f but wanted %f", got, expected) } } { var strtod func(arg string, ptr **byte) float64 purego.RegisterLibFunc(&strtod, libc, "strtod") const ( arg = "1" ) got := strtod(arg, nil) expected := float64(1) if got != expected { t.Errorf("strtod failed. got %f but wanted %f", got, expected) } } } func TestRegisterLibFunc_Bool(t *testing.T) { if runtime.GOARCH != "arm64" && runtime.GOARCH != "amd64" && runtime.GOARCH != "loong64" { t.Skip("Platform doesn't support callbacks") return } // this callback recreates the state where the return register // contains other information but the least significant byte is false cbFalse := purego.NewCallback(func() uintptr { x := uint64(0x7F5948AE9A00) return uintptr(x) }) var runFalse func() bool purego.RegisterFunc(&runFalse, cbFalse) expected := false if got := runFalse(); got != expected { t.Errorf("runFalse failed. got %t but wanted %t", got, expected) } } func TestABI(t *testing.T) { if runtime.GOOS == "windows" && runtime.GOARCH == "386" { t.Skip("need a 32bit gcc to run this test") // TODO: find 32bit gcc for test } libFileName := filepath.Join(t.TempDir(), "abitest.so") t.Logf("Build %v", libFileName) if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "abitest", "abi_test.c")); err != nil { t.Fatal(err) } lib, err := load.OpenLibrary(libFileName) if err != nil { t.Fatalf("Dlopen(%q) failed: %v", libFileName, err) } defer func() { if err := load.CloseLibrary(lib); err != nil { t.Fatalf("failed to close library: %s", err) } }() { const cName = "stack_uint8_t" const expect = 2047 var fn func(a, b, c, d, e, f, g, h uint32, i, j uint8, k uint32) uint32 purego.RegisterLibFunc(&fn, lib, cName) res := fn(256, 512, 4, 8, 16, 32, 64, 128, 1, 2, 1024) if res != expect { t.Fatalf("%s: got %d, want %d", cName, res, expect) } } { const cName = "reg_uint8_t" const expect = 1027 var fn func(a, b uint8, c uint32) uint32 purego.RegisterLibFunc(&fn, lib, cName) res := fn(1, 2, 1024) if res != expect { t.Fatalf("%s: got %d, want %d", cName, res, expect) } } { const cName = "stack_string" const expect = 255 var fn func(a, b, c, d, e, f, g, h uint32, i string) uint32 purego.RegisterLibFunc(&fn, lib, cName) res := fn(1, 2, 4, 8, 16, 32, 64, 128, "test") if res != expect { t.Fatalf("%s: got %d, want %d", cName, res, expect) } } { const cName = "stack_8i32_3strings" var fn func(*byte, uintptr, int32, int32, int32, int32, int32, int32, int32, int32, string, string, string) purego.RegisterLibFunc(&fn, lib, cName) buf := make([]byte, 256) fn(&buf[0], uintptr(len(buf)), 1, 2, 3, 4, 5, 6, 7, 8, "foo", "bar", "baz") res := string(buf[:strings.IndexByte(string(buf), 0)]) const want = "1:2:3:4:5:6:7:8:foo:bar:baz" if res != want { t.Fatalf("%s: got %q, want %q", cName, res, want) } } } func buildSharedLib(compilerEnv, libFile string, sources ...string) error { out, err := exec.Command("go", "env", compilerEnv).Output() if err != nil { return fmt.Errorf("go env %s error: %w", compilerEnv, err) } compiler := strings.TrimSpace(string(out)) if compiler == "" { return errors.New("compiler not found") } args := []string{"-shared", "-Wall", "-Werror", "-fPIC", "-o", libFile} if runtime.GOARCH == "386" { args = append(args, "-m32") } // macOS arm64 can run amd64 tests through Rossetta. // Build the shared library based on the GOARCH and not // the default behavior of the compiler. if runtime.GOOS == "darwin" { var arch string switch runtime.GOARCH { case "arm64": arch = "arm64" case "amd64": arch = "x86_64" default: return fmt.Errorf("unknown macOS architecture %s", runtime.GOARCH) } args = append(args, "-arch", arch) } cmd := exec.Command(compiler, append(args, sources...)...) if out, err := cmd.CombinedOutput(); err != nil { return fmt.Errorf("compile lib: %w\n%q\n%s", err, cmd, string(out)) } return nil } golang-github-ebitengine-purego-0.9.1/gen.go000066400000000000000000000002231512124053000207440ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors package purego //go:generate go run wincallback.go golang-github-ebitengine-purego-0.9.1/go.mod000066400000000000000000000000551512124053000207550ustar00rootroot00000000000000module github.com/ebitengine/purego go 1.18 golang-github-ebitengine-purego-0.9.1/go.sum000066400000000000000000000000001512124053000207700ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/go_runtime.go000066400000000000000000000005061512124053000223470ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build darwin || freebsd || linux || netbsd || windows package purego import ( "unsafe" ) //go:linkname runtime_cgocall runtime.cgocall func runtime_cgocall(fn uintptr, arg unsafe.Pointer) int32 // from runtime/sys_libc.go golang-github-ebitengine-purego-0.9.1/internal/000077500000000000000000000000001512124053000214635ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/internal/buildtest/000077500000000000000000000000001512124053000234625ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/internal/buildtest/main.go000066400000000000000000000004441512124053000247370ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors //go:build !windows package main import ( _ "github.com/ebitengine/purego" ) import "C" // This file tests that build Cgo and purego at the same time succeeds to build (#189). func main() { } golang-github-ebitengine-purego-0.9.1/internal/cgo/000077500000000000000000000000001512124053000222335ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/internal/cgo/dlfcn_cgo_unix.go000066400000000000000000000023561512124053000255510ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors //go:build freebsd || linux || netbsd package cgo /* #cgo !netbsd LDFLAGS: -ldl #include #include */ import "C" import ( "errors" "unsafe" ) func Dlopen(filename string, flag int) (uintptr, error) { cfilename := C.CString(filename) defer C.free(unsafe.Pointer(cfilename)) handle := C.dlopen(cfilename, C.int(flag)) if handle == nil { return 0, errors.New(C.GoString(C.dlerror())) } return uintptr(handle), nil } func Dlsym(handle uintptr, symbol string) (uintptr, error) { csymbol := C.CString(symbol) defer C.free(unsafe.Pointer(csymbol)) symbolAddr := C.dlsym(*(*unsafe.Pointer)(unsafe.Pointer(&handle)), csymbol) if symbolAddr == nil { return 0, errors.New(C.GoString(C.dlerror())) } return uintptr(symbolAddr), nil } func Dlclose(handle uintptr) error { result := C.dlclose(*(*unsafe.Pointer)(unsafe.Pointer(&handle))) if result != 0 { return errors.New(C.GoString(C.dlerror())) } return nil } // all that is needed is to assign each dl function because then its // symbol will then be made available to the linker and linked to inside dlfcn.go var ( _ = C.dlopen _ = C.dlsym _ = C.dlerror _ = C.dlclose ) golang-github-ebitengine-purego-0.9.1/internal/cgo/empty.go000066400000000000000000000002771512124053000237260ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors package cgo // Empty so that importing this package doesn't cause issue for certain platforms. golang-github-ebitengine-purego-0.9.1/internal/cgo/syscall_cgo_unix.go000066400000000000000000000036331512124053000261340ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build freebsd || (linux && !(arm64 || amd64 || loong64)) || netbsd package cgo // this file is placed inside internal/cgo and not package purego // because Cgo and assembly files can't be in the same package. /* #cgo !netbsd LDFLAGS: -ldl #include #include #include #include typedef struct syscall15Args { uintptr_t fn; uintptr_t a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15; uintptr_t f1, f2, f3, f4, f5, f6, f7, f8; uintptr_t err; } syscall15Args; void syscall15(struct syscall15Args *args) { assert((args->f1|args->f2|args->f3|args->f4|args->f5|args->f6|args->f7|args->f8) == 0); uintptr_t (*func_name)(uintptr_t a1, uintptr_t a2, uintptr_t a3, uintptr_t a4, uintptr_t a5, uintptr_t a6, uintptr_t a7, uintptr_t a8, uintptr_t a9, uintptr_t a10, uintptr_t a11, uintptr_t a12, uintptr_t a13, uintptr_t a14, uintptr_t a15); *(void**)(&func_name) = (void*)(args->fn); uintptr_t r1 = func_name(args->a1,args->a2,args->a3,args->a4,args->a5,args->a6,args->a7,args->a8,args->a9, args->a10,args->a11,args->a12,args->a13,args->a14,args->a15); args->a1 = r1; args->err = errno; } */ import "C" import "unsafe" // assign purego.syscall15XABI0 to the C version of this function. var Syscall15XABI0 = unsafe.Pointer(C.syscall15) //go:nosplit func Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) { args := C.syscall15Args{ C.uintptr_t(fn), C.uintptr_t(a1), C.uintptr_t(a2), C.uintptr_t(a3), C.uintptr_t(a4), C.uintptr_t(a5), C.uintptr_t(a6), C.uintptr_t(a7), C.uintptr_t(a8), C.uintptr_t(a9), C.uintptr_t(a10), C.uintptr_t(a11), C.uintptr_t(a12), C.uintptr_t(a13), C.uintptr_t(a14), C.uintptr_t(a15), 0, 0, 0, 0, 0, 0, 0, 0, 0, } C.syscall15(&args) return uintptr(args.a1), 0, uintptr(args.err) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/000077500000000000000000000000001512124053000230625ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/internal/fakecgo/abi_amd64.h000066400000000000000000000053531512124053000247670ustar00rootroot00000000000000// Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Macros for transitioning from the host ABI to Go ABI0. // // These save the frame pointer, so in general, functions that use // these should have zero frame size to suppress the automatic frame // pointer, though it's harmless to not do this. #ifdef GOOS_windows // REGS_HOST_TO_ABI0_STACK is the stack bytes used by // PUSH_REGS_HOST_TO_ABI0. #define REGS_HOST_TO_ABI0_STACK (28*8 + 8) // PUSH_REGS_HOST_TO_ABI0 prepares for transitioning from // the host ABI to Go ABI0 code. It saves all registers that are // callee-save in the host ABI and caller-save in Go ABI0 and prepares // for entry to Go. // // Save DI SI BP BX R12 R13 R14 R15 X6-X15 registers and the DF flag. // Clear the DF flag for the Go ABI. // MXCSR matches the Go ABI, so we don't have to set that, // and Go doesn't modify it, so we don't have to save it. #define PUSH_REGS_HOST_TO_ABI0() \ PUSHFQ \ CLD \ ADJSP $(REGS_HOST_TO_ABI0_STACK - 8) \ MOVQ DI, (0*0)(SP) \ MOVQ SI, (1*8)(SP) \ MOVQ BP, (2*8)(SP) \ MOVQ BX, (3*8)(SP) \ MOVQ R12, (4*8)(SP) \ MOVQ R13, (5*8)(SP) \ MOVQ R14, (6*8)(SP) \ MOVQ R15, (7*8)(SP) \ MOVUPS X6, (8*8)(SP) \ MOVUPS X7, (10*8)(SP) \ MOVUPS X8, (12*8)(SP) \ MOVUPS X9, (14*8)(SP) \ MOVUPS X10, (16*8)(SP) \ MOVUPS X11, (18*8)(SP) \ MOVUPS X12, (20*8)(SP) \ MOVUPS X13, (22*8)(SP) \ MOVUPS X14, (24*8)(SP) \ MOVUPS X15, (26*8)(SP) #define POP_REGS_HOST_TO_ABI0() \ MOVQ (0*0)(SP), DI \ MOVQ (1*8)(SP), SI \ MOVQ (2*8)(SP), BP \ MOVQ (3*8)(SP), BX \ MOVQ (4*8)(SP), R12 \ MOVQ (5*8)(SP), R13 \ MOVQ (6*8)(SP), R14 \ MOVQ (7*8)(SP), R15 \ MOVUPS (8*8)(SP), X6 \ MOVUPS (10*8)(SP), X7 \ MOVUPS (12*8)(SP), X8 \ MOVUPS (14*8)(SP), X9 \ MOVUPS (16*8)(SP), X10 \ MOVUPS (18*8)(SP), X11 \ MOVUPS (20*8)(SP), X12 \ MOVUPS (22*8)(SP), X13 \ MOVUPS (24*8)(SP), X14 \ MOVUPS (26*8)(SP), X15 \ ADJSP $-(REGS_HOST_TO_ABI0_STACK - 8) \ POPFQ #else // SysV ABI #define REGS_HOST_TO_ABI0_STACK (6*8) // SysV MXCSR matches the Go ABI, so we don't have to set that, // and Go doesn't modify it, so we don't have to save it. // Both SysV and Go require DF to be cleared, so that's already clear. // The SysV and Go frame pointer conventions are compatible. #define PUSH_REGS_HOST_TO_ABI0() \ ADJSP $(REGS_HOST_TO_ABI0_STACK) \ MOVQ BP, (5*8)(SP) \ LEAQ (5*8)(SP), BP \ MOVQ BX, (0*8)(SP) \ MOVQ R12, (1*8)(SP) \ MOVQ R13, (2*8)(SP) \ MOVQ R14, (3*8)(SP) \ MOVQ R15, (4*8)(SP) #define POP_REGS_HOST_TO_ABI0() \ MOVQ (0*8)(SP), BX \ MOVQ (1*8)(SP), R12 \ MOVQ (2*8)(SP), R13 \ MOVQ (3*8)(SP), R14 \ MOVQ (4*8)(SP), R15 \ MOVQ (5*8)(SP), BP \ ADJSP $-(REGS_HOST_TO_ABI0_STACK) #endif golang-github-ebitengine-purego-0.9.1/internal/fakecgo/abi_arm64.h000066400000000000000000000027671512124053000250130ustar00rootroot00000000000000// Copyright 2021 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Macros for transitioning from the host ABI to Go ABI0. // // These macros save and restore the callee-saved registers // from the stack, but they don't adjust stack pointer, so // the user should prepare stack space in advance. // SAVE_R19_TO_R28(offset) saves R19 ~ R28 to the stack space // of ((offset)+0*8)(RSP) ~ ((offset)+9*8)(RSP). // // SAVE_F8_TO_F15(offset) saves F8 ~ F15 to the stack space // of ((offset)+0*8)(RSP) ~ ((offset)+7*8)(RSP). // // R29 is not saved because Go will save and restore it. #define SAVE_R19_TO_R28(offset) \ STP (R19, R20), ((offset)+0*8)(RSP) \ STP (R21, R22), ((offset)+2*8)(RSP) \ STP (R23, R24), ((offset)+4*8)(RSP) \ STP (R25, R26), ((offset)+6*8)(RSP) \ STP (R27, g), ((offset)+8*8)(RSP) #define RESTORE_R19_TO_R28(offset) \ LDP ((offset)+0*8)(RSP), (R19, R20) \ LDP ((offset)+2*8)(RSP), (R21, R22) \ LDP ((offset)+4*8)(RSP), (R23, R24) \ LDP ((offset)+6*8)(RSP), (R25, R26) \ LDP ((offset)+8*8)(RSP), (R27, g) /* R28 */ #define SAVE_F8_TO_F15(offset) \ FSTPD (F8, F9), ((offset)+0*8)(RSP) \ FSTPD (F10, F11), ((offset)+2*8)(RSP) \ FSTPD (F12, F13), ((offset)+4*8)(RSP) \ FSTPD (F14, F15), ((offset)+6*8)(RSP) #define RESTORE_F8_TO_F15(offset) \ FLDPD ((offset)+0*8)(RSP), (F8, F9) \ FLDPD ((offset)+2*8)(RSP), (F10, F11) \ FLDPD ((offset)+4*8)(RSP), (F12, F13) \ FLDPD ((offset)+6*8)(RSP), (F14, F15) golang-github-ebitengine-purego-0.9.1/internal/fakecgo/abi_loong64.h000066400000000000000000000037121512124053000253410ustar00rootroot00000000000000// Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. // Macros for transitioning from the host ABI to Go ABI0. // // These macros save and restore the callee-saved registers // from the stack, but they don't adjust stack pointer, so // the user should prepare stack space in advance. // SAVE_R22_TO_R31(offset) saves R22 ~ R31 to the stack space // of ((offset)+0*8)(R3) ~ ((offset)+9*8)(R3). // // SAVE_F24_TO_F31(offset) saves F24 ~ F31 to the stack space // of ((offset)+0*8)(R3) ~ ((offset)+7*8)(R3). // // Note: g is R22 #define SAVE_R22_TO_R31(offset) \ MOVV g, ((offset)+(0*8))(R3) \ MOVV R23, ((offset)+(1*8))(R3) \ MOVV R24, ((offset)+(2*8))(R3) \ MOVV R25, ((offset)+(3*8))(R3) \ MOVV R26, ((offset)+(4*8))(R3) \ MOVV R27, ((offset)+(5*8))(R3) \ MOVV R28, ((offset)+(6*8))(R3) \ MOVV R29, ((offset)+(7*8))(R3) \ MOVV R30, ((offset)+(8*8))(R3) \ MOVV R31, ((offset)+(9*8))(R3) #define SAVE_F24_TO_F31(offset) \ MOVD F24, ((offset)+(0*8))(R3) \ MOVD F25, ((offset)+(1*8))(R3) \ MOVD F26, ((offset)+(2*8))(R3) \ MOVD F27, ((offset)+(3*8))(R3) \ MOVD F28, ((offset)+(4*8))(R3) \ MOVD F29, ((offset)+(5*8))(R3) \ MOVD F30, ((offset)+(6*8))(R3) \ MOVD F31, ((offset)+(7*8))(R3) #define RESTORE_R22_TO_R31(offset) \ MOVV ((offset)+(0*8))(R3), g \ MOVV ((offset)+(1*8))(R3), R23 \ MOVV ((offset)+(2*8))(R3), R24 \ MOVV ((offset)+(3*8))(R3), R25 \ MOVV ((offset)+(4*8))(R3), R26 \ MOVV ((offset)+(5*8))(R3), R27 \ MOVV ((offset)+(6*8))(R3), R28 \ MOVV ((offset)+(7*8))(R3), R29 \ MOVV ((offset)+(8*8))(R3), R30 \ MOVV ((offset)+(9*8))(R3), R31 #define RESTORE_F24_TO_F31(offset) \ MOVD ((offset)+(0*8))(R3), F24 \ MOVD ((offset)+(1*8))(R3), F25 \ MOVD ((offset)+(2*8))(R3), F26 \ MOVD ((offset)+(3*8))(R3), F27 \ MOVD ((offset)+(4*8))(R3), F28 \ MOVD ((offset)+(5*8))(R3), F29 \ MOVD ((offset)+(6*8))(R3), F30 \ MOVD ((offset)+(7*8))(R3), F31 golang-github-ebitengine-purego-0.9.1/internal/fakecgo/asm_amd64.s000066400000000000000000000016361512124053000250270ustar00rootroot00000000000000// Copyright 2009 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. #include "textflag.h" #include "abi_amd64.h" // Called by C code generated by cmd/cgo. // func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) // Saves C callee-saved registers and calls cgocallback with three arguments. // fn is the PC of a func(a unsafe.Pointer) function. // This signature is known to SWIG, so we can't change it. TEXT crosscall2(SB), NOSPLIT, $0-0 PUSH_REGS_HOST_TO_ABI0() // Make room for arguments to cgocallback. ADJSP $0x18 #ifndef GOOS_windows MOVQ DI, 0x0(SP) // fn MOVQ SI, 0x8(SP) // arg // Skip n in DX. MOVQ CX, 0x10(SP) // ctxt #else MOVQ CX, 0x0(SP) // fn MOVQ DX, 0x8(SP) // arg // Skip n in R8. MOVQ R9, 0x10(SP) // ctxt #endif CALL runtime·cgocallback(SB) ADJSP $-0x18 POP_REGS_HOST_TO_ABI0() RET golang-github-ebitengine-purego-0.9.1/internal/fakecgo/asm_arm64.s000066400000000000000000000020051512124053000250340ustar00rootroot00000000000000// Copyright 2015 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. #include "textflag.h" #include "abi_arm64.h" // Called by C code generated by cmd/cgo. // func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) // Saves C callee-saved registers and calls cgocallback with three arguments. // fn is the PC of a func(a unsafe.Pointer) function. TEXT crosscall2(SB), NOSPLIT|NOFRAME, $0 /* * We still need to save all callee save register as before, and then * push 3 args for fn (R0, R1, R3), skipping R2. * Also note that at procedure entry in gc world, 8(RSP) will be the * first arg. */ SUB $(8*24), RSP STP (R0, R1), (8*1)(RSP) MOVD R3, (8*3)(RSP) SAVE_R19_TO_R28(8*4) SAVE_F8_TO_F15(8*14) STP (R29, R30), (8*22)(RSP) // Initialize Go ABI environment BL runtime·load_g(SB) BL runtime·cgocallback(SB) RESTORE_R19_TO_R28(8*4) RESTORE_F8_TO_F15(8*14) LDP (8*22)(RSP), (R29, R30) ADD $(8*24), RSP RET golang-github-ebitengine-purego-0.9.1/internal/fakecgo/asm_loong64.s000066400000000000000000000021161512124053000253760ustar00rootroot00000000000000// Copyright 2022 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. #include "textflag.h" #include "abi_loong64.h" // Called by C code generated by cmd/cgo. // func crosscall2(fn, a unsafe.Pointer, n int32, ctxt uintptr) // Saves C callee-saved registers and calls cgocallback with three arguments. // fn is the PC of a func(a unsafe.Pointer) function. TEXT crosscall2(SB),NOSPLIT|NOFRAME,$0 /* * We still need to save all callee save register as before, and then * push 3 args for fn (R4, R5, R7), skipping R6. * Also note that at procedure entry in gc world, 8(R29) will be the * first arg. */ ADDV $(-23*8), R3 MOVV R4, (1*8)(R3) // fn unsafe.Pointer MOVV R5, (2*8)(R3) // a unsafe.Pointer MOVV R7, (3*8)(R3) // ctxt uintptr SAVE_R22_TO_R31((4*8)) SAVE_F24_TO_F31((14*8)) MOVV R1, (22*8)(R3) // Initialize Go ABI environment JAL runtime·load_g(SB) JAL runtime·cgocallback(SB) RESTORE_R22_TO_R31((4*8)) RESTORE_F24_TO_F31((14*8)) MOVV (22*8)(R3), R1 ADDV $(23*8), R3 RET golang-github-ebitengine-purego-0.9.1/internal/fakecgo/callbacks.go000066400000000000000000000071761512124053000253430ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo import ( _ "unsafe" ) // TODO: decide if we need _runtime_cgo_panic_internal //go:linkname x_cgo_init_trampoline x_cgo_init_trampoline //go:linkname _cgo_init _cgo_init var x_cgo_init_trampoline byte var _cgo_init = &x_cgo_init_trampoline // Creates a new system thread without updating any Go state. // // This method is invoked during shared library loading to create a new OS // thread to perform the runtime initialization. This method is similar to // _cgo_sys_thread_start except that it doesn't update any Go state. //go:linkname x_cgo_thread_start_trampoline x_cgo_thread_start_trampoline //go:linkname _cgo_thread_start _cgo_thread_start var x_cgo_thread_start_trampoline byte var _cgo_thread_start = &x_cgo_thread_start_trampoline // Notifies that the runtime has been initialized. // // We currently block at every CGO entry point (via _cgo_wait_runtime_init_done) // to ensure that the runtime has been initialized before the CGO call is // executed. This is necessary for shared libraries where we kickoff runtime // initialization in a separate thread and return without waiting for this // thread to complete the init. //go:linkname x_cgo_notify_runtime_init_done_trampoline x_cgo_notify_runtime_init_done_trampoline //go:linkname _cgo_notify_runtime_init_done _cgo_notify_runtime_init_done var x_cgo_notify_runtime_init_done_trampoline byte var _cgo_notify_runtime_init_done = &x_cgo_notify_runtime_init_done_trampoline // Indicates whether a dummy thread key has been created or not. // // When calling go exported function from C, we register a destructor // callback, for a dummy thread key, by using pthread_key_create. //go:linkname _cgo_pthread_key_created _cgo_pthread_key_created var x_cgo_pthread_key_created uintptr var _cgo_pthread_key_created = &x_cgo_pthread_key_created // Set the x_crosscall2_ptr C function pointer variable point to crosscall2. // It's for the runtime package to call at init time. func set_crosscall2() { // nothing needs to be done here for fakecgo // because it's possible to just call cgocallback directly } //go:linkname _set_crosscall2 runtime.set_crosscall2 var _set_crosscall2 = set_crosscall2 // Store the g into the thread-specific value. // So that pthread_key_destructor will dropm when the thread is exiting. //go:linkname x_cgo_bindm_trampoline x_cgo_bindm_trampoline //go:linkname _cgo_bindm _cgo_bindm var x_cgo_bindm_trampoline byte var _cgo_bindm = &x_cgo_bindm_trampoline // TODO: decide if we need x_cgo_set_context_function // TODO: decide if we need _cgo_yield var ( // In Go 1.20 the race detector was rewritten to pure Go // on darwin. This means that when CGO_ENABLED=0 is set // fakecgo is built with race detector code. This is not // good since this code is pretending to be C. The go:norace // pragma is not enough, since it only applies to the native // ABIInternal function. The ABIO wrapper (which is necessary, // since all references to text symbols from assembly will use it) // does not inherit the go:norace pragma, so it will still be // instrumented by the race detector. // // To circumvent this issue, using closure calls in the // assembly, which forces the compiler to use the ABIInternal // native implementation (which has go:norace) instead. threadentry_call = threadentry x_cgo_init_call = x_cgo_init x_cgo_setenv_call = x_cgo_setenv x_cgo_unsetenv_call = x_cgo_unsetenv x_cgo_thread_start_call = x_cgo_thread_start ) golang-github-ebitengine-purego-0.9.1/internal/fakecgo/doc.go000066400000000000000000000023701512124053000241600ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) // Package fakecgo implements the Cgo runtime (runtime/cgo) entirely in Go. // This allows code that calls into C to function properly when CGO_ENABLED=0. // // # Goals // // fakecgo attempts to replicate the same naming structure as in the runtime. // For example, functions that have the prefix "gcc_*" are named "go_*". // This makes it easier to port other GOOSs and GOARCHs as well as to keep // it in sync with runtime/cgo. // // # Support // // Currently, fakecgo only supports macOS on amd64 & arm64. It also cannot // be used with -buildmode=c-archive because that requires special initialization // that fakecgo does not implement at the moment. // // # Usage // // Using fakecgo is easy just import _ "github.com/ebitengine/purego" and then // set the environment variable CGO_ENABLED=0. // The recommended usage for fakecgo is to prefer using runtime/cgo if possible // but if cross-compiling or fast build times are important fakecgo is available. // Purego will pick which ever Cgo runtime is available and prefer the one that // comes with Go (runtime/cgo). package fakecgo //go:generate go run gen.go golang-github-ebitengine-purego-0.9.1/internal/fakecgo/freebsd.go000066400000000000000000000014311512124053000250220ustar00rootroot00000000000000// Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build freebsd && !cgo package fakecgo import _ "unsafe" // for go:linkname // Supply environ and __progname, because we don't // link against the standard FreeBSD crt0.o and the // libc dynamic library needs them. // Note: when building with cross-compiling or CGO_ENABLED=0, add // the following argument to `go` so that these symbols are defined by // making fakecgo the Cgo. // -gcflags="github.com/ebitengine/purego/internal/fakecgo=-std" //go:linkname _environ environ //go:linkname _progname __progname //go:cgo_export_dynamic environ //go:cgo_export_dynamic __progname var _environ uintptr var _progname uintptr golang-github-ebitengine-purego-0.9.1/internal/fakecgo/gen.go000066400000000000000000000145331512124053000241700ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build ignore package main import ( "bytes" "fmt" "go/format" "log" "os" "strings" "text/template" ) const templateSymbols = `// Code generated by 'go generate' with gen.go. DO NOT EDIT. // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo import ( "syscall" "unsafe" ) // setg_trampoline calls setg with the G provided func setg_trampoline(setg uintptr, G uintptr) // call5 takes fn the C function and 5 arguments and calls the function with those arguments func call5(fn, a1, a2, a3, a4, a5 uintptr) uintptr {{ range . -}} //go:nosplit //go:norace func {{.Name}}( {{- range .Args -}} {{- if .Name -}} {{.Name}} {{.Type}}, {{- end -}} {{- end -}}) {{.Return}} { {{- if .Return -}} {{- if eq .Return "unsafe.Pointer" -}} ret := {{- else -}} return {{.Return}}( {{- end -}} {{- end -}} call5({{.Name}}ABI0, {{- range .Args}} {{- if .Name -}} {{- if hasPrefix .Type "*" -}} uintptr(unsafe.Pointer({{.Name}})), {{- else -}} uintptr({{.Name}}), {{- end -}} {{- else -}} 0, {{- end -}} {{- end -}} ) {{/* end of call5 */}} {{- if .Return -}} {{- if eq .Return "unsafe.Pointer"}} // this indirection is to avoid go vet complaining about possible misuse of unsafe.Pointer return *(*unsafe.Pointer)(unsafe.Pointer(&ret)) {{- else -}} ) {{/* end of cast */}} {{- end -}} {{- end}} } {{end}} {{- range . }} //go:linkname _{{.Name}} _{{.Name}} var _{{.Name}} uint8 var {{.Name}}ABI0 = uintptr(unsafe.Pointer(&_{{.Name}})) {{ end }} ` const templateTrampolinesStubs = `// Code generated by 'go generate' with gen.go. DO NOT EDIT. // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) #include "textflag.h" // these stubs are here because it is not possible to go:linkname directly the C functions on darwin arm64 {{ range . }} TEXT _{{.Name}}(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_{{.Name}}(SB) RET {{ end -}} ` const templateSymbolsGoos = `// Code generated by 'go generate' with gen.go. DO NOT EDIT. // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo package fakecgo {{- range $location := . }} {{- range .Symbols }} //go:cgo_import_dynamic purego_{{ .Name }} {{ .Name }} "{{ $location.SharedObject }}" {{- end }} {{- end }} ` type Arg struct { Name string Type string } type Symbol struct { Name string Args [5]Arg Return string } type LocatedSymbols struct { SharedObject string Symbols []Symbol } var ( libcSymbols = []Symbol{ {"malloc", [5]Arg{{"size", "uintptr"}}, "unsafe.Pointer"}, {"free", [5]Arg{{"ptr", "unsafe.Pointer"}}, ""}, {"setenv", [5]Arg{{"name", "*byte"}, {"value", "*byte"}, {"overwrite", "int32"}}, "int32"}, {"unsetenv", [5]Arg{{"name", "*byte"}}, "int32"}, {"sigfillset", [5]Arg{{"set", "*sigset_t"}}, "int32"}, {"nanosleep", [5]Arg{{"ts", "*syscall.Timespec"}, {"rem", "*syscall.Timespec"}}, "int32"}, {"abort", [5]Arg{}, ""}, {"sigaltstack", [5]Arg{{"ss", "*stack_t"}, {"old_ss", "*stack_t"}}, "int32"}, } pthreadSymbols = []Symbol{ {"pthread_attr_init", [5]Arg{{"attr", "*pthread_attr_t"}}, "int32"}, {"pthread_create", [5]Arg{{"thread", "*pthread_t"}, {"attr", "*pthread_attr_t"}, {"start", "unsafe.Pointer"}, {"arg", "unsafe.Pointer"}}, "int32"}, {"pthread_detach", [5]Arg{{"thread", "pthread_t"}}, "int32"}, {"pthread_sigmask", [5]Arg{{"how", "sighow"}, {"ign", "*sigset_t"}, {"oset", "*sigset_t"}}, "int32"}, {"pthread_self", [5]Arg{}, "pthread_t"}, {"pthread_get_stacksize_np", [5]Arg{{"thread", "pthread_t"}}, "size_t"}, {"pthread_attr_getstacksize", [5]Arg{{"attr", "*pthread_attr_t"}, {"stacksize", "*size_t"}}, "int32"}, {"pthread_attr_setstacksize", [5]Arg{{"attr", "*pthread_attr_t"}, {"size", "size_t"}}, "int32"}, {"pthread_attr_destroy", [5]Arg{{"attr", "*pthread_attr_t"}}, "int32"}, {"pthread_mutex_lock", [5]Arg{{"mutex", "*pthread_mutex_t"}}, "int32"}, {"pthread_mutex_unlock", [5]Arg{{"mutex", "*pthread_mutex_t"}}, "int32"}, {"pthread_cond_broadcast", [5]Arg{{"cond", "*pthread_cond_t"}}, "int32"}, {"pthread_setspecific", [5]Arg{{"key", "pthread_key_t"}, {"value", "unsafe.Pointer"}}, "int32"}, } ) var funcs = map[string]any{ "hasPrefix": strings.HasPrefix, } func run() error { t, err := template.New("symbol.go").Funcs(funcs).Parse(templateSymbols) if err != nil { return err } f, err := os.Create("symbols.go") defer f.Close() if err != nil { return err } allSymbols := append(append([]Symbol{}, libcSymbols...), pthreadSymbols...) buf := new(bytes.Buffer) if err := t.Execute(buf, allSymbols); err != nil { return err } source, err := format.Source(buf.Bytes()) if err != nil { return err } if _, err = f.Write(source); err != nil { return err } t, err = template.New("trampolines_stubs.s").Funcs(funcs).Parse(templateTrampolinesStubs) if err != nil { return err } f, err = os.Create("trampolines_stubs.s") defer f.Close() if err != nil { return err } if err := t.Execute(f, allSymbols); err != nil { return err } t, err = template.New("symbols_goos.go").Parse(templateSymbolsGoos) if err != nil { return err } for _, goos := range []string{"darwin", "freebsd", "linux", "netbsd"} { f, err = os.Create(fmt.Sprintf("symbols_%s.go", goos)) defer f.Close() if err != nil { return err } b := &bytes.Buffer{} var libcSO, pthreadSO string switch goos { case "darwin": libcSO = "/usr/lib/libSystem.B.dylib" pthreadSO = "/usr/lib/libSystem.B.dylib" case "freebsd": libcSO = "libc.so.7" pthreadSO = "libpthread.so" case "linux": libcSO = "libc.so.6" pthreadSO = "libpthread.so.0" case "netbsd": libcSO = "libc.so" pthreadSO = "libpthread.so" default: return fmt.Errorf("unsupported OS: %s", goos) } located := []LocatedSymbols{ {SharedObject: libcSO, Symbols: libcSymbols}, {SharedObject: pthreadSO, Symbols: pthreadSymbols}, } if err = t.Execute(b, located); err != nil { return err } var src []byte src, err = format.Source(b.Bytes()) if err != nil { return err } if _, err = f.Write(src); err != nil { return err } } return nil } func main() { if err := run(); err != nil { log.Fatal(err) } } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_darwin_amd64.go000066400000000000000000000033371512124053000263630ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo package fakecgo import "unsafe" //go:nosplit //go:norace func _cgo_sys_thread_start(ts *ThreadStart) { var attr pthread_attr_t var ign, oset sigset_t var p pthread_t var size size_t var err int sigfillset(&ign) pthread_sigmask(SIG_SETMASK, &ign, &oset) size = pthread_get_stacksize_np(pthread_self()) pthread_attr_init(&attr) pthread_attr_setstacksize(&attr, size) // Leave stacklo=0 and set stackhi=size; mstart will do the rest. ts.g.stackhi = uintptr(size) err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) pthread_sigmask(SIG_SETMASK, &oset, nil) if err != 0 { print("fakecgo: pthread_create failed: ") println(err) abort() } } // threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function // //go:linkname x_threadentry_trampoline threadentry_trampoline var x_threadentry_trampoline byte var threadentry_trampolineABI0 = &x_threadentry_trampoline //go:nosplit //go:norace func threadentry(v unsafe.Pointer) unsafe.Pointer { ts := *(*ThreadStart)(v) free(v) setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) // faking funcs in go is a bit a... involved - but the following works :) fn := uintptr(unsafe.Pointer(&ts.fn)) (*(*func())(unsafe.Pointer(&fn)))() return nil } // here we will store a pointer to the provided setg func var setg_func uintptr //go:nosplit //go:norace func x_cgo_init(g *G, setg uintptr) { var size size_t setg_func = setg size = pthread_get_stacksize_np(pthread_self()) g.stacklo = uintptr(unsafe.Add(unsafe.Pointer(&size), -size+4096)) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_darwin_arm64.go000066400000000000000000000045211512124053000263750ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo package fakecgo import "unsafe" //go:nosplit //go:norace func _cgo_sys_thread_start(ts *ThreadStart) { var attr pthread_attr_t var ign, oset sigset_t var p pthread_t var size size_t var err int sigfillset(&ign) pthread_sigmask(SIG_SETMASK, &ign, &oset) size = pthread_get_stacksize_np(pthread_self()) pthread_attr_init(&attr) pthread_attr_setstacksize(&attr, size) // Leave stacklo=0 and set stackhi=size; mstart will do the rest. ts.g.stackhi = uintptr(size) err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) pthread_sigmask(SIG_SETMASK, &oset, nil) if err != 0 { print("fakecgo: pthread_create failed: ") println(err) abort() } } // threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function // //go:linkname x_threadentry_trampoline threadentry_trampoline var x_threadentry_trampoline byte var threadentry_trampolineABI0 = &x_threadentry_trampoline //go:nosplit //go:norace func threadentry(v unsafe.Pointer) unsafe.Pointer { ts := *(*ThreadStart)(v) free(v) // TODO: support ios //#if TARGET_OS_IPHONE // darwin_arm_init_thread_exception_port(); //#endif setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) // faking funcs in go is a bit a... involved - but the following works :) fn := uintptr(unsafe.Pointer(&ts.fn)) (*(*func())(unsafe.Pointer(&fn)))() return nil } // here we will store a pointer to the provided setg func var setg_func uintptr // x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c) // This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us // Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup // This function can't be go:systemstack since go is not in a state where the systemcheck would work. // //go:nosplit //go:norace func x_cgo_init(g *G, setg uintptr) { var size size_t setg_func = setg size = pthread_get_stacksize_np(pthread_self()) g.stacklo = uintptr(unsafe.Add(unsafe.Pointer(&size), -size+4096)) //TODO: support ios //#if TARGET_OS_IPHONE // darwin_arm_init_mach_exception_handler(); // darwin_arm_init_thread_exception_port(); // init_working_dir(); //#endif } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_freebsd_amd64.go000066400000000000000000000054401512124053000265060ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo package fakecgo import "unsafe" //go:nosplit func _cgo_sys_thread_start(ts *ThreadStart) { var attr pthread_attr_t var ign, oset sigset_t var p pthread_t var size size_t var err int //fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug sigfillset(&ign) pthread_sigmask(SIG_SETMASK, &ign, &oset) pthread_attr_init(&attr) pthread_attr_getstacksize(&attr, &size) // Leave stacklo=0 and set stackhi=size; mstart will do the rest. ts.g.stackhi = uintptr(size) err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) pthread_sigmask(SIG_SETMASK, &oset, nil) if err != 0 { print("fakecgo: pthread_create failed: ") println(err) abort() } } // threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function // //go:linkname x_threadentry_trampoline threadentry_trampoline var x_threadentry_trampoline byte var threadentry_trampolineABI0 = &x_threadentry_trampoline //go:nosplit func threadentry(v unsafe.Pointer) unsafe.Pointer { ts := *(*ThreadStart)(v) free(v) setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) // faking funcs in go is a bit a... involved - but the following works :) fn := uintptr(unsafe.Pointer(&ts.fn)) (*(*func())(unsafe.Pointer(&fn)))() return nil } // here we will store a pointer to the provided setg func var setg_func uintptr //go:nosplit func x_cgo_init(g *G, setg uintptr) { var size size_t var attr *pthread_attr_t /* The memory sanitizer distributed with versions of clang before 3.8 has a bug: if you call mmap before malloc, mmap may return an address that is later overwritten by the msan library. Avoid this problem by forcing a call to malloc here, before we ever call malloc. This is only required for the memory sanitizer, so it's unfortunate that we always run it. It should be possible to remove this when we no longer care about versions of clang before 3.8. The test for this is misc/cgo/testsanitizers. GCC works hard to eliminate a seemingly unnecessary call to malloc, so we actually use the memory we allocate. */ setg_func = setg attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr))) if attr == nil { println("fakecgo: malloc failed") abort() } pthread_attr_init(attr) pthread_attr_getstacksize(attr, &size) // runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))` // but this should be OK since we are taking the address of the first variable in this function. g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096 pthread_attr_destroy(attr) free(unsafe.Pointer(attr)) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_freebsd_arm64.go000066400000000000000000000057061512124053000265310ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo package fakecgo import "unsafe" //go:nosplit func _cgo_sys_thread_start(ts *ThreadStart) { var attr pthread_attr_t var ign, oset sigset_t var p pthread_t var size size_t var err int // fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug sigfillset(&ign) pthread_sigmask(SIG_SETMASK, &ign, &oset) pthread_attr_init(&attr) pthread_attr_getstacksize(&attr, &size) // Leave stacklo=0 and set stackhi=size; mstart will do the rest. ts.g.stackhi = uintptr(size) err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) pthread_sigmask(SIG_SETMASK, &oset, nil) if err != 0 { print("fakecgo: pthread_create failed: ") println(err) abort() } } // threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function // //go:linkname x_threadentry_trampoline threadentry_trampoline var x_threadentry_trampoline byte var threadentry_trampolineABI0 = &x_threadentry_trampoline //go:nosplit func threadentry(v unsafe.Pointer) unsafe.Pointer { ts := *(*ThreadStart)(v) free(v) setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) // faking funcs in go is a bit a... involved - but the following works :) fn := uintptr(unsafe.Pointer(&ts.fn)) (*(*func())(unsafe.Pointer(&fn)))() return nil } // here we will store a pointer to the provided setg func var setg_func uintptr // x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c) // This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us // Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup // This function can't be go:systemstack since go is not in a state where the systemcheck would work. // //go:nosplit func x_cgo_init(g *G, setg uintptr) { var size size_t var attr *pthread_attr_t /* The memory sanitizer distributed with versions of clang before 3.8 has a bug: if you call mmap before malloc, mmap may return an address that is later overwritten by the msan library. Avoid this problem by forcing a call to malloc here, before we ever call malloc. This is only required for the memory sanitizer, so it's unfortunate that we always run it. It should be possible to remove this when we no longer care about versions of clang before 3.8. The test for this is misc/cgo/testsanitizers. GCC works hard to eliminate a seemingly unnecessary call to malloc, so we actually use the memory we allocate. */ setg_func = setg attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr))) if attr == nil { println("fakecgo: malloc failed") abort() } pthread_attr_init(attr) pthread_attr_getstacksize(attr, &size) g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096 pthread_attr_destroy(attr) free(unsafe.Pointer(attr)) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_libinit.go000066400000000000000000000043311512124053000255310ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo import ( "syscall" "unsafe" ) var ( pthread_g pthread_key_t runtime_init_cond = PTHREAD_COND_INITIALIZER runtime_init_mu = PTHREAD_MUTEX_INITIALIZER runtime_init_done int ) //go:nosplit //go:norace func x_cgo_notify_runtime_init_done() { pthread_mutex_lock(&runtime_init_mu) runtime_init_done = 1 pthread_cond_broadcast(&runtime_init_cond) pthread_mutex_unlock(&runtime_init_mu) } // Store the g into a thread-specific value associated with the pthread key pthread_g. // And pthread_key_destructor will dropm when the thread is exiting. // //go:norace func x_cgo_bindm(g unsafe.Pointer) { // We assume this will always succeed, otherwise, there might be extra M leaking, // when a C thread exits after a cgo call. // We only invoke this function once per thread in runtime.needAndBindM, // and the next calls just reuse the bound m. pthread_setspecific(pthread_g, g) } // _cgo_try_pthread_create retries pthread_create if it fails with // EAGAIN. // //go:nosplit //go:norace func _cgo_try_pthread_create(thread *pthread_t, attr *pthread_attr_t, pfn unsafe.Pointer, arg *ThreadStart) int { var ts syscall.Timespec // tries needs to be the same type as syscall.Timespec.Nsec // but the fields are int32 on 32bit and int64 on 64bit. // tries is assigned to syscall.Timespec.Nsec in order to match its type. tries := ts.Nsec var err int for tries = 0; tries < 20; tries++ { // inlined this call because it ran out of stack when inlining was disabled err = int(call5(pthread_createABI0, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(pfn), uintptr(unsafe.Pointer(arg)), 0)) if err == 0 { // inlined this call because it ran out of stack when inlining was disabled call5(pthread_detachABI0, uintptr(*thread), 0, 0, 0, 0) return 0 } if err != int(syscall.EAGAIN) { return err } ts.Sec = 0 ts.Nsec = (tries + 1) * 1000 * 1000 // Milliseconds. // inlined this call because it ran out of stack when inlining was disabled call5(nanosleepABI0, uintptr(unsafe.Pointer(&ts)), 0, 0, 0, 0) } return int(syscall.EAGAIN) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_linux_amd64.go000066400000000000000000000054401512124053000262330ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo package fakecgo import "unsafe" //go:nosplit func _cgo_sys_thread_start(ts *ThreadStart) { var attr pthread_attr_t var ign, oset sigset_t var p pthread_t var size size_t var err int //fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug sigfillset(&ign) pthread_sigmask(SIG_SETMASK, &ign, &oset) pthread_attr_init(&attr) pthread_attr_getstacksize(&attr, &size) // Leave stacklo=0 and set stackhi=size; mstart will do the rest. ts.g.stackhi = uintptr(size) err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) pthread_sigmask(SIG_SETMASK, &oset, nil) if err != 0 { print("fakecgo: pthread_create failed: ") println(err) abort() } } // threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function // //go:linkname x_threadentry_trampoline threadentry_trampoline var x_threadentry_trampoline byte var threadentry_trampolineABI0 = &x_threadentry_trampoline //go:nosplit func threadentry(v unsafe.Pointer) unsafe.Pointer { ts := *(*ThreadStart)(v) free(v) setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) // faking funcs in go is a bit a... involved - but the following works :) fn := uintptr(unsafe.Pointer(&ts.fn)) (*(*func())(unsafe.Pointer(&fn)))() return nil } // here we will store a pointer to the provided setg func var setg_func uintptr //go:nosplit func x_cgo_init(g *G, setg uintptr) { var size size_t var attr *pthread_attr_t /* The memory sanitizer distributed with versions of clang before 3.8 has a bug: if you call mmap before malloc, mmap may return an address that is later overwritten by the msan library. Avoid this problem by forcing a call to malloc here, before we ever call malloc. This is only required for the memory sanitizer, so it's unfortunate that we always run it. It should be possible to remove this when we no longer care about versions of clang before 3.8. The test for this is misc/cgo/testsanitizers. GCC works hard to eliminate a seemingly unnecessary call to malloc, so we actually use the memory we allocate. */ setg_func = setg attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr))) if attr == nil { println("fakecgo: malloc failed") abort() } pthread_attr_init(attr) pthread_attr_getstacksize(attr, &size) // runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))` // but this should be OK since we are taking the address of the first variable in this function. g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096 pthread_attr_destroy(attr) free(unsafe.Pointer(attr)) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_linux_arm64.go000066400000000000000000000057051512124053000262550ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo package fakecgo import "unsafe" //go:nosplit func _cgo_sys_thread_start(ts *ThreadStart) { var attr pthread_attr_t var ign, oset sigset_t var p pthread_t var size size_t var err int //fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug sigfillset(&ign) pthread_sigmask(SIG_SETMASK, &ign, &oset) pthread_attr_init(&attr) pthread_attr_getstacksize(&attr, &size) // Leave stacklo=0 and set stackhi=size; mstart will do the rest. ts.g.stackhi = uintptr(size) err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) pthread_sigmask(SIG_SETMASK, &oset, nil) if err != 0 { print("fakecgo: pthread_create failed: ") println(err) abort() } } // threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function // //go:linkname x_threadentry_trampoline threadentry_trampoline var x_threadentry_trampoline byte var threadentry_trampolineABI0 = &x_threadentry_trampoline //go:nosplit func threadentry(v unsafe.Pointer) unsafe.Pointer { ts := *(*ThreadStart)(v) free(v) setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) // faking funcs in go is a bit a... involved - but the following works :) fn := uintptr(unsafe.Pointer(&ts.fn)) (*(*func())(unsafe.Pointer(&fn)))() return nil } // here we will store a pointer to the provided setg func var setg_func uintptr // x_cgo_init(G *g, void (*setg)(void*)) (runtime/cgo/gcc_linux_amd64.c) // This get's called during startup, adjusts stacklo, and provides a pointer to setg_gcc for us // Additionally, if we set _cgo_init to non-null, go won't do it's own TLS setup // This function can't be go:systemstack since go is not in a state where the systemcheck would work. // //go:nosplit func x_cgo_init(g *G, setg uintptr) { var size size_t var attr *pthread_attr_t /* The memory sanitizer distributed with versions of clang before 3.8 has a bug: if you call mmap before malloc, mmap may return an address that is later overwritten by the msan library. Avoid this problem by forcing a call to malloc here, before we ever call malloc. This is only required for the memory sanitizer, so it's unfortunate that we always run it. It should be possible to remove this when we no longer care about versions of clang before 3.8. The test for this is misc/cgo/testsanitizers. GCC works hard to eliminate a seemingly unnecessary call to malloc, so we actually use the memory we allocate. */ setg_func = setg attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr))) if attr == nil { println("fakecgo: malloc failed") abort() } pthread_attr_init(attr) pthread_attr_getstacksize(attr, &size) g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096 pthread_attr_destroy(attr) free(unsafe.Pointer(attr)) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_linux_loong64.go000066400000000000000000000050011512124053000266010ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo package fakecgo import "unsafe" //go:nosplit func _cgo_sys_thread_start(ts *ThreadStart) { var attr pthread_attr_t var ign, oset sigset_t var p pthread_t var size size_t var err int sigfillset(&ign) pthread_sigmask(SIG_SETMASK, &ign, &oset) pthread_attr_init(&attr) pthread_attr_getstacksize(&attr, &size) // Leave stacklo=0 and set stackhi=size; mstart will do the rest. ts.g.stackhi = uintptr(size) err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) pthread_sigmask(SIG_SETMASK, &oset, nil) if err != 0 { print("fakecgo: pthread_create failed: ") println(err) abort() } } // threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function // //go:linkname x_threadentry_trampoline threadentry_trampoline var x_threadentry_trampoline byte var threadentry_trampolineABI0 = &x_threadentry_trampoline //go:nosplit func threadentry(v unsafe.Pointer) unsafe.Pointer { ts := *(*ThreadStart)(v) free(v) setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) // faking funcs in go is a bit a... involved - but the following works :) fn := uintptr(unsafe.Pointer(&ts.fn)) (*(*func())(unsafe.Pointer(&fn)))() return nil } // here we will store a pointer to the provided setg func var setg_func uintptr //go:nosplit func x_cgo_init(g *G, setg uintptr) { var size size_t var attr *pthread_attr_t /* The memory sanitizer distributed with versions of clang before 3.8 has a bug: if you call mmap before malloc, mmap may return an address that is later overwritten by the msan library. Avoid this problem by forcing a call to malloc here, before we ever call malloc. This is only required for the memory sanitizer, so it's unfortunate that we always run it. It should be possible to remove this when we no longer care about versions of clang before 3.8. The test for this is misc/cgo/testsanitizers. GCC works hard to eliminate a seemingly unnecessary call to malloc, so we actually use the memory we allocate. */ setg_func = setg attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr))) if attr == nil { println("fakecgo: malloc failed") abort() } pthread_attr_init(attr) pthread_attr_getstacksize(attr, &size) g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096 pthread_attr_destroy(attr) free(unsafe.Pointer(attr)) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_netbsd.go000066400000000000000000000064041512124053000253610ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo && (amd64 || arm64) package fakecgo import "unsafe" //go:nosplit func _cgo_sys_thread_start(ts *ThreadStart) { var attr pthread_attr_t var ign, oset sigset_t var p pthread_t var size size_t var err int // fprintf(stderr, "runtime/cgo: _cgo_sys_thread_start: fn=%p, g=%p\n", ts->fn, ts->g); // debug sigfillset(&ign) pthread_sigmask(SIG_SETMASK, &ign, &oset) pthread_attr_init(&attr) pthread_attr_getstacksize(&attr, &size) // Leave stacklo=0 and set stackhi=size; mstart will do the rest. ts.g.stackhi = uintptr(size) err = _cgo_try_pthread_create(&p, &attr, unsafe.Pointer(threadentry_trampolineABI0), ts) pthread_sigmask(SIG_SETMASK, &oset, nil) if err != 0 { print("fakecgo: pthread_create failed: ") println(err) abort() } } // threadentry_trampolineABI0 maps the C ABI to Go ABI then calls the Go function // //go:linkname x_threadentry_trampoline threadentry_trampoline var x_threadentry_trampoline byte var threadentry_trampolineABI0 = &x_threadentry_trampoline //go:nosplit func threadentry(v unsafe.Pointer) unsafe.Pointer { var ss stack_t ts := *(*ThreadStart)(v) free(v) // On NetBSD, a new thread inherits the signal stack of the // creating thread. That confuses minit, so we remove that // signal stack here before calling the regular mstart. It's // a bit baroque to remove a signal stack here only to add one // in minit, but it's a simple change that keeps NetBSD // working like other OS's. At this point all signals are // blocked, so there is no race. ss.ss_flags = SS_DISABLE sigaltstack(&ss, nil) setg_trampoline(setg_func, uintptr(unsafe.Pointer(ts.g))) // faking funcs in go is a bit a... involved - but the following works :) fn := uintptr(unsafe.Pointer(&ts.fn)) (*(*func())(unsafe.Pointer(&fn)))() return nil } // here we will store a pointer to the provided setg func var setg_func uintptr //go:nosplit func x_cgo_init(g *G, setg uintptr) { var size size_t var attr *pthread_attr_t /* The memory sanitizer distributed with versions of clang before 3.8 has a bug: if you call mmap before malloc, mmap may return an address that is later overwritten by the msan library. Avoid this problem by forcing a call to malloc here, before we ever call malloc. This is only required for the memory sanitizer, so it's unfortunate that we always run it. It should be possible to remove this when we no longer care about versions of clang before 3.8. The test for this is misc/cgo/testsanitizers. GCC works hard to eliminate a seemingly unnecessary call to malloc, so we actually use the memory we allocate. */ setg_func = setg attr = (*pthread_attr_t)(malloc(unsafe.Sizeof(*attr))) if attr == nil { println("fakecgo: malloc failed") abort() } pthread_attr_init(attr) pthread_attr_getstacksize(attr, &size) // runtime/cgo uses __builtin_frame_address(0) instead of `uintptr(unsafe.Pointer(&size))` // but this should be OK since we are taking the address of the first variable in this function. g.stacklo = uintptr(unsafe.Pointer(&size)) - uintptr(size) + 4096 pthread_attr_destroy(attr) free(unsafe.Pointer(attr)) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_setenv.go000066400000000000000000000005271512124053000254060ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo //go:nosplit //go:norace func x_cgo_setenv(arg *[2]*byte) { setenv(arg[0], arg[1], 1) } //go:nosplit //go:norace func x_cgo_unsetenv(arg *[1]*byte) { unsetenv(arg[0]) } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/go_util.go000066400000000000000000000024331512124053000250550ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo import "unsafe" // _cgo_thread_start is split into three parts in cgo since only one part is system dependent (keep it here for easier handling) // _cgo_thread_start(ThreadStart *arg) (runtime/cgo/gcc_util.c) // This get's called instead of the go code for creating new threads // -> pthread_* stuff is used, so threads are setup correctly for C // If this is missing, TLS is only setup correctly on thread 1! // This function should be go:systemstack instead of go:nosplit (but that requires runtime) // //go:nosplit //go:norace func x_cgo_thread_start(arg *ThreadStart) { var ts *ThreadStart // Make our own copy that can persist after we return. // _cgo_tsan_acquire(); ts = (*ThreadStart)(malloc(unsafe.Sizeof(*ts))) // _cgo_tsan_release(); if ts == nil { println("fakecgo: out of memory in thread_start") abort() } // *ts = *arg would cause a writebarrier so copy using slices s1 := unsafe.Slice((*uintptr)(unsafe.Pointer(ts)), unsafe.Sizeof(*ts)/8) s2 := unsafe.Slice((*uintptr)(unsafe.Pointer(arg)), unsafe.Sizeof(*arg)/8) for i := range s2 { s1[i] = s2[i] } _cgo_sys_thread_start(ts) // OS-dependent half } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/iscgo.go000066400000000000000000000013051512124053000245140ustar00rootroot00000000000000// Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo && (darwin || freebsd || linux || netbsd) // The runtime package contains an uninitialized definition // for runtime·iscgo. Override it to tell the runtime we're here. // There are various function pointers that should be set too, // but those depend on dynamic linker magic to get initialized // correctly, and sometimes they break. This variable is a // backup: it depends only on old C style static linking rules. package fakecgo import _ "unsafe" // for go:linkname //go:linkname _iscgo runtime.iscgo var _iscgo bool = true golang-github-ebitengine-purego-0.9.1/internal/fakecgo/libcgo.go000066400000000000000000000016721512124053000246560ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo type ( size_t uintptr // Sources: // Darwin (32 bytes) - https://github.com/apple/darwin-xnu/blob/2ff845c2e033bd0ff64b5b6aa6063a1f8f65aa32/bsd/sys/_types.h#L74 // FreeBSD (32 bytes) - https://github.com/DoctorWkt/xv6-freebsd/blob/d2a294c2a984baed27676068b15ed9a29b06ab6f/include/signal.h#L98C9-L98C21 // Linux (128 bytes) - https://github.com/torvalds/linux/blob/ab75170520d4964f3acf8bb1f91d34cbc650688e/arch/x86/include/asm/signal.h#L25 sigset_t [128]byte pthread_attr_t [64]byte pthread_t int pthread_key_t uint64 ) // for pthread_sigmask: type sighow int32 const ( SIG_BLOCK sighow = 0 SIG_UNBLOCK sighow = 1 SIG_SETMASK sighow = 2 ) type G struct { stacklo uintptr stackhi uintptr } type ThreadStart struct { g *G tls *uintptr fn uintptr } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/libcgo_darwin.go000066400000000000000000000006711512124053000262200ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo package fakecgo type ( pthread_mutex_t struct { sig int64 opaque [56]byte } pthread_cond_t struct { sig int64 opaque [40]byte } ) var ( PTHREAD_COND_INITIALIZER = pthread_cond_t{sig: 0x3CB0B1BB} PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t{sig: 0x32AAABA7} ) type stack_t struct { /* not implemented */ } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/libcgo_freebsd.go000066400000000000000000000005241512124053000263430ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo package fakecgo type ( pthread_cond_t uintptr pthread_mutex_t uintptr ) var ( PTHREAD_COND_INITIALIZER = pthread_cond_t(0) PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0) ) type stack_t struct { /* not implemented */ } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/libcgo_linux.go000066400000000000000000000005241512124053000260700ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo package fakecgo type ( pthread_cond_t [48]byte pthread_mutex_t [48]byte ) var ( PTHREAD_COND_INITIALIZER = pthread_cond_t{} PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t{} ) type stack_t struct { /* not implemented */ } golang-github-ebitengine-purego-0.9.1/internal/fakecgo/libcgo_netbsd.go000066400000000000000000000011761512124053000262140ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors //go:build !cgo package fakecgo type ( pthread_cond_t uintptr pthread_mutex_t uintptr ) var ( PTHREAD_COND_INITIALIZER = pthread_cond_t(0) PTHREAD_MUTEX_INITIALIZER = pthread_mutex_t(0) ) // Source: https://github.com/NetBSD/src/blob/613e27c65223fd2283b6ed679da1197e12f50e27/sys/compat/linux/arch/m68k/linux_signal.h#L133 type stack_t struct { ss_sp uintptr ss_flags int32 ss_size uintptr } // Source: https://github.com/NetBSD/src/blob/613e27c65223fd2283b6ed679da1197e12f50e27/sys/sys/signal.h#L261 const SS_DISABLE = 0x004 golang-github-ebitengine-purego-0.9.1/internal/fakecgo/netbsd.go000066400000000000000000000010561512124053000246720ustar00rootroot00000000000000// Copyright 2010 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build netbsd package fakecgo import _ "unsafe" // for go:linkname // Supply environ and __progname, because we don't // link against the standard NetBSD crt0.o and the // libc dynamic library needs them. //go:linkname _environ environ //go:linkname _progname __progname //go:linkname ___ps_strings __ps_strings var ( _environ uintptr _progname uintptr ___ps_strings uintptr ) golang-github-ebitengine-purego-0.9.1/internal/fakecgo/setenv.go000066400000000000000000000012211512124053000247110ustar00rootroot00000000000000// Copyright 2011 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo import _ "unsafe" // for go:linkname //go:linkname x_cgo_setenv_trampoline x_cgo_setenv_trampoline //go:linkname _cgo_setenv runtime._cgo_setenv var x_cgo_setenv_trampoline byte var _cgo_setenv = &x_cgo_setenv_trampoline //go:linkname x_cgo_unsetenv_trampoline x_cgo_unsetenv_trampoline //go:linkname _cgo_unsetenv runtime._cgo_unsetenv var x_cgo_unsetenv_trampoline byte var _cgo_unsetenv = &x_cgo_unsetenv_trampoline golang-github-ebitengine-purego-0.9.1/internal/fakecgo/symbols.go000066400000000000000000000161351512124053000251070ustar00rootroot00000000000000// Code generated by 'go generate' with gen.go. DO NOT EDIT. // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) package fakecgo import ( "syscall" "unsafe" ) // setg_trampoline calls setg with the G provided func setg_trampoline(setg uintptr, G uintptr) // call5 takes fn the C function and 5 arguments and calls the function with those arguments func call5(fn, a1, a2, a3, a4, a5 uintptr) uintptr //go:nosplit //go:norace func malloc(size uintptr) unsafe.Pointer { ret := call5(mallocABI0, uintptr(size), 0, 0, 0, 0) // this indirection is to avoid go vet complaining about possible misuse of unsafe.Pointer return *(*unsafe.Pointer)(unsafe.Pointer(&ret)) } //go:nosplit //go:norace func free(ptr unsafe.Pointer) { call5(freeABI0, uintptr(ptr), 0, 0, 0, 0) } //go:nosplit //go:norace func setenv(name *byte, value *byte, overwrite int32) int32 { return int32(call5(setenvABI0, uintptr(unsafe.Pointer(name)), uintptr(unsafe.Pointer(value)), uintptr(overwrite), 0, 0)) } //go:nosplit //go:norace func unsetenv(name *byte) int32 { return int32(call5(unsetenvABI0, uintptr(unsafe.Pointer(name)), 0, 0, 0, 0)) } //go:nosplit //go:norace func sigfillset(set *sigset_t) int32 { return int32(call5(sigfillsetABI0, uintptr(unsafe.Pointer(set)), 0, 0, 0, 0)) } //go:nosplit //go:norace func nanosleep(ts *syscall.Timespec, rem *syscall.Timespec) int32 { return int32(call5(nanosleepABI0, uintptr(unsafe.Pointer(ts)), uintptr(unsafe.Pointer(rem)), 0, 0, 0)) } //go:nosplit //go:norace func abort() { call5(abortABI0, 0, 0, 0, 0, 0) } //go:nosplit //go:norace func sigaltstack(ss *stack_t, old_ss *stack_t) int32 { return int32(call5(sigaltstackABI0, uintptr(unsafe.Pointer(ss)), uintptr(unsafe.Pointer(old_ss)), 0, 0, 0)) } //go:nosplit //go:norace func pthread_attr_init(attr *pthread_attr_t) int32 { return int32(call5(pthread_attr_initABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0)) } //go:nosplit //go:norace func pthread_create(thread *pthread_t, attr *pthread_attr_t, start unsafe.Pointer, arg unsafe.Pointer) int32 { return int32(call5(pthread_createABI0, uintptr(unsafe.Pointer(thread)), uintptr(unsafe.Pointer(attr)), uintptr(start), uintptr(arg), 0)) } //go:nosplit //go:norace func pthread_detach(thread pthread_t) int32 { return int32(call5(pthread_detachABI0, uintptr(thread), 0, 0, 0, 0)) } //go:nosplit //go:norace func pthread_sigmask(how sighow, ign *sigset_t, oset *sigset_t) int32 { return int32(call5(pthread_sigmaskABI0, uintptr(how), uintptr(unsafe.Pointer(ign)), uintptr(unsafe.Pointer(oset)), 0, 0)) } //go:nosplit //go:norace func pthread_self() pthread_t { return pthread_t(call5(pthread_selfABI0, 0, 0, 0, 0, 0)) } //go:nosplit //go:norace func pthread_get_stacksize_np(thread pthread_t) size_t { return size_t(call5(pthread_get_stacksize_npABI0, uintptr(thread), 0, 0, 0, 0)) } //go:nosplit //go:norace func pthread_attr_getstacksize(attr *pthread_attr_t, stacksize *size_t) int32 { return int32(call5(pthread_attr_getstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(unsafe.Pointer(stacksize)), 0, 0, 0)) } //go:nosplit //go:norace func pthread_attr_setstacksize(attr *pthread_attr_t, size size_t) int32 { return int32(call5(pthread_attr_setstacksizeABI0, uintptr(unsafe.Pointer(attr)), uintptr(size), 0, 0, 0)) } //go:nosplit //go:norace func pthread_attr_destroy(attr *pthread_attr_t) int32 { return int32(call5(pthread_attr_destroyABI0, uintptr(unsafe.Pointer(attr)), 0, 0, 0, 0)) } //go:nosplit //go:norace func pthread_mutex_lock(mutex *pthread_mutex_t) int32 { return int32(call5(pthread_mutex_lockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0)) } //go:nosplit //go:norace func pthread_mutex_unlock(mutex *pthread_mutex_t) int32 { return int32(call5(pthread_mutex_unlockABI0, uintptr(unsafe.Pointer(mutex)), 0, 0, 0, 0)) } //go:nosplit //go:norace func pthread_cond_broadcast(cond *pthread_cond_t) int32 { return int32(call5(pthread_cond_broadcastABI0, uintptr(unsafe.Pointer(cond)), 0, 0, 0, 0)) } //go:nosplit //go:norace func pthread_setspecific(key pthread_key_t, value unsafe.Pointer) int32 { return int32(call5(pthread_setspecificABI0, uintptr(key), uintptr(value), 0, 0, 0)) } //go:linkname _malloc _malloc var _malloc uint8 var mallocABI0 = uintptr(unsafe.Pointer(&_malloc)) //go:linkname _free _free var _free uint8 var freeABI0 = uintptr(unsafe.Pointer(&_free)) //go:linkname _setenv _setenv var _setenv uint8 var setenvABI0 = uintptr(unsafe.Pointer(&_setenv)) //go:linkname _unsetenv _unsetenv var _unsetenv uint8 var unsetenvABI0 = uintptr(unsafe.Pointer(&_unsetenv)) //go:linkname _sigfillset _sigfillset var _sigfillset uint8 var sigfillsetABI0 = uintptr(unsafe.Pointer(&_sigfillset)) //go:linkname _nanosleep _nanosleep var _nanosleep uint8 var nanosleepABI0 = uintptr(unsafe.Pointer(&_nanosleep)) //go:linkname _abort _abort var _abort uint8 var abortABI0 = uintptr(unsafe.Pointer(&_abort)) //go:linkname _sigaltstack _sigaltstack var _sigaltstack uint8 var sigaltstackABI0 = uintptr(unsafe.Pointer(&_sigaltstack)) //go:linkname _pthread_attr_init _pthread_attr_init var _pthread_attr_init uint8 var pthread_attr_initABI0 = uintptr(unsafe.Pointer(&_pthread_attr_init)) //go:linkname _pthread_create _pthread_create var _pthread_create uint8 var pthread_createABI0 = uintptr(unsafe.Pointer(&_pthread_create)) //go:linkname _pthread_detach _pthread_detach var _pthread_detach uint8 var pthread_detachABI0 = uintptr(unsafe.Pointer(&_pthread_detach)) //go:linkname _pthread_sigmask _pthread_sigmask var _pthread_sigmask uint8 var pthread_sigmaskABI0 = uintptr(unsafe.Pointer(&_pthread_sigmask)) //go:linkname _pthread_self _pthread_self var _pthread_self uint8 var pthread_selfABI0 = uintptr(unsafe.Pointer(&_pthread_self)) //go:linkname _pthread_get_stacksize_np _pthread_get_stacksize_np var _pthread_get_stacksize_np uint8 var pthread_get_stacksize_npABI0 = uintptr(unsafe.Pointer(&_pthread_get_stacksize_np)) //go:linkname _pthread_attr_getstacksize _pthread_attr_getstacksize var _pthread_attr_getstacksize uint8 var pthread_attr_getstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_getstacksize)) //go:linkname _pthread_attr_setstacksize _pthread_attr_setstacksize var _pthread_attr_setstacksize uint8 var pthread_attr_setstacksizeABI0 = uintptr(unsafe.Pointer(&_pthread_attr_setstacksize)) //go:linkname _pthread_attr_destroy _pthread_attr_destroy var _pthread_attr_destroy uint8 var pthread_attr_destroyABI0 = uintptr(unsafe.Pointer(&_pthread_attr_destroy)) //go:linkname _pthread_mutex_lock _pthread_mutex_lock var _pthread_mutex_lock uint8 var pthread_mutex_lockABI0 = uintptr(unsafe.Pointer(&_pthread_mutex_lock)) //go:linkname _pthread_mutex_unlock _pthread_mutex_unlock var _pthread_mutex_unlock uint8 var pthread_mutex_unlockABI0 = uintptr(unsafe.Pointer(&_pthread_mutex_unlock)) //go:linkname _pthread_cond_broadcast _pthread_cond_broadcast var _pthread_cond_broadcast uint8 var pthread_cond_broadcastABI0 = uintptr(unsafe.Pointer(&_pthread_cond_broadcast)) //go:linkname _pthread_setspecific _pthread_setspecific var _pthread_setspecific uint8 var pthread_setspecificABI0 = uintptr(unsafe.Pointer(&_pthread_setspecific)) golang-github-ebitengine-purego-0.9.1/internal/fakecgo/symbols_darwin.go000066400000000000000000000040651512124053000264520ustar00rootroot00000000000000// Code generated by 'go generate' with gen.go. DO NOT EDIT. // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo package fakecgo //go:cgo_import_dynamic purego_malloc malloc "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_free free "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_setenv setenv "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_unsetenv unsetenv "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_sigfillset sigfillset "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_nanosleep nanosleep "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_abort abort "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_sigaltstack sigaltstack "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_create pthread_create "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_detach pthread_detach "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_self pthread_self "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_get_stacksize_np pthread_get_stacksize_np "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_attr_setstacksize pthread_attr_setstacksize "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "/usr/lib/libSystem.B.dylib" //go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "/usr/lib/libSystem.B.dylib" golang-github-ebitengine-purego-0.9.1/internal/fakecgo/symbols_freebsd.go000066400000000000000000000034041512124053000265740ustar00rootroot00000000000000// Code generated by 'go generate' with gen.go. DO NOT EDIT. // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo package fakecgo //go:cgo_import_dynamic purego_malloc malloc "libc.so.7" //go:cgo_import_dynamic purego_free free "libc.so.7" //go:cgo_import_dynamic purego_setenv setenv "libc.so.7" //go:cgo_import_dynamic purego_unsetenv unsetenv "libc.so.7" //go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so.7" //go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so.7" //go:cgo_import_dynamic purego_abort abort "libc.so.7" //go:cgo_import_dynamic purego_sigaltstack sigaltstack "libc.so.7" //go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so" //go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so" //go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so" //go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so" //go:cgo_import_dynamic purego_pthread_self pthread_self "libpthread.so" //go:cgo_import_dynamic purego_pthread_get_stacksize_np pthread_get_stacksize_np "libpthread.so" //go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so" //go:cgo_import_dynamic purego_pthread_attr_setstacksize pthread_attr_setstacksize "libpthread.so" //go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "libpthread.so" //go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "libpthread.so" //go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "libpthread.so" //go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "libpthread.so" //go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "libpthread.so" golang-github-ebitengine-purego-0.9.1/internal/fakecgo/symbols_linux.go000066400000000000000000000034361512124053000263260ustar00rootroot00000000000000// Code generated by 'go generate' with gen.go. DO NOT EDIT. // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo package fakecgo //go:cgo_import_dynamic purego_malloc malloc "libc.so.6" //go:cgo_import_dynamic purego_free free "libc.so.6" //go:cgo_import_dynamic purego_setenv setenv "libc.so.6" //go:cgo_import_dynamic purego_unsetenv unsetenv "libc.so.6" //go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so.6" //go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so.6" //go:cgo_import_dynamic purego_abort abort "libc.so.6" //go:cgo_import_dynamic purego_sigaltstack sigaltstack "libc.so.6" //go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_self pthread_self "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_get_stacksize_np pthread_get_stacksize_np "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_attr_setstacksize pthread_attr_setstacksize "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "libpthread.so.0" //go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "libpthread.so.0" golang-github-ebitengine-purego-0.9.1/internal/fakecgo/symbols_netbsd.go000066400000000000000000000033641512124053000264460ustar00rootroot00000000000000// Code generated by 'go generate' with gen.go. DO NOT EDIT. // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo package fakecgo //go:cgo_import_dynamic purego_malloc malloc "libc.so" //go:cgo_import_dynamic purego_free free "libc.so" //go:cgo_import_dynamic purego_setenv setenv "libc.so" //go:cgo_import_dynamic purego_unsetenv unsetenv "libc.so" //go:cgo_import_dynamic purego_sigfillset sigfillset "libc.so" //go:cgo_import_dynamic purego_nanosleep nanosleep "libc.so" //go:cgo_import_dynamic purego_abort abort "libc.so" //go:cgo_import_dynamic purego_sigaltstack sigaltstack "libc.so" //go:cgo_import_dynamic purego_pthread_attr_init pthread_attr_init "libpthread.so" //go:cgo_import_dynamic purego_pthread_create pthread_create "libpthread.so" //go:cgo_import_dynamic purego_pthread_detach pthread_detach "libpthread.so" //go:cgo_import_dynamic purego_pthread_sigmask pthread_sigmask "libpthread.so" //go:cgo_import_dynamic purego_pthread_self pthread_self "libpthread.so" //go:cgo_import_dynamic purego_pthread_get_stacksize_np pthread_get_stacksize_np "libpthread.so" //go:cgo_import_dynamic purego_pthread_attr_getstacksize pthread_attr_getstacksize "libpthread.so" //go:cgo_import_dynamic purego_pthread_attr_setstacksize pthread_attr_setstacksize "libpthread.so" //go:cgo_import_dynamic purego_pthread_attr_destroy pthread_attr_destroy "libpthread.so" //go:cgo_import_dynamic purego_pthread_mutex_lock pthread_mutex_lock "libpthread.so" //go:cgo_import_dynamic purego_pthread_mutex_unlock pthread_mutex_unlock "libpthread.so" //go:cgo_import_dynamic purego_pthread_cond_broadcast pthread_cond_broadcast "libpthread.so" //go:cgo_import_dynamic purego_pthread_setspecific pthread_setspecific "libpthread.so" golang-github-ebitengine-purego-0.9.1/internal/fakecgo/trampolines_amd64.s000066400000000000000000000044151512124053000266020ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || linux || freebsd) /* trampoline for emulating required C functions for cgo in go (see cgo.go) (we convert cdecl calling convention to go and vice-versa) Since we're called from go and call into C we can cheat a bit with the calling conventions: - in go all the registers are caller saved - in C we have a couple of callee saved registers => we can use BX, R12, R13, R14, R15 instead of the stack C Calling convention cdecl used here (we only need integer args): 1. arg: DI 2. arg: SI 3. arg: DX 4. arg: CX 5. arg: R8 6. arg: R9 We don't need floats with these functions -> AX=0 return value will be in AX */ #include "textflag.h" #include "go_asm.h" // these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions. TEXT x_cgo_init_trampoline(SB), NOSPLIT, $16 MOVQ DI, AX MOVQ SI, BX MOVQ ·x_cgo_init_call(SB), DX MOVQ (DX), CX CALL CX RET TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8 MOVQ DI, AX MOVQ ·x_cgo_thread_start_call(SB), DX MOVQ (DX), CX CALL CX RET TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8 MOVQ DI, AX MOVQ ·x_cgo_setenv_call(SB), DX MOVQ (DX), CX CALL CX RET TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8 MOVQ DI, AX MOVQ ·x_cgo_unsetenv_call(SB), DX MOVQ (DX), CX CALL CX RET TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0 CALL ·x_cgo_notify_runtime_init_done(SB) RET TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 CALL ·x_cgo_bindm(SB) RET // func setg_trampoline(setg uintptr, g uintptr) TEXT ·setg_trampoline(SB), NOSPLIT, $0-16 MOVQ G+8(FP), DI MOVQ setg+0(FP), BX XORL AX, AX CALL BX RET TEXT threadentry_trampoline(SB), NOSPLIT, $16 MOVQ DI, AX MOVQ ·threadentry_call(SB), DX MOVQ (DX), CX CALL CX RET TEXT ·call5(SB), NOSPLIT, $0-56 MOVQ fn+0(FP), BX MOVQ a1+8(FP), DI MOVQ a2+16(FP), SI MOVQ a3+24(FP), DX MOVQ a4+32(FP), CX MOVQ a5+40(FP), R8 XORL AX, AX // no floats PUSHQ BP // save BP MOVQ SP, BP // save SP inside BP bc BP is callee-saved SUBQ $16, SP // allocate space for alignment ANDQ $-16, SP // align on 16 bytes for SSE CALL BX MOVQ BP, SP // get SP back POPQ BP // restore BP MOVQ AX, ret+48(FP) RET golang-github-ebitengine-purego-0.9.1/internal/fakecgo/trampolines_arm64.s000066400000000000000000000030521512124053000266140ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux) #include "textflag.h" #include "go_asm.h" // these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions. TEXT x_cgo_init_trampoline(SB), NOSPLIT, $0-0 MOVD R0, 8(RSP) MOVD R1, 16(RSP) MOVD ·x_cgo_init_call(SB), R26 MOVD (R26), R2 CALL (R2) RET TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $0-0 MOVD R0, 8(RSP) MOVD ·x_cgo_thread_start_call(SB), R26 MOVD (R26), R2 CALL (R2) RET TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $0-0 MOVD R0, 8(RSP) MOVD ·x_cgo_setenv_call(SB), R26 MOVD (R26), R2 CALL (R2) RET TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $0-0 MOVD R0, 8(RSP) MOVD ·x_cgo_unsetenv_call(SB), R26 MOVD (R26), R2 CALL (R2) RET TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0-0 CALL ·x_cgo_notify_runtime_init_done(SB) RET TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 CALL ·x_cgo_bindm(SB) RET // func setg_trampoline(setg uintptr, g uintptr) TEXT ·setg_trampoline(SB), NOSPLIT, $0-16 MOVD G+8(FP), R0 MOVD setg+0(FP), R1 CALL R1 RET TEXT threadentry_trampoline(SB), NOSPLIT, $0-0 MOVD R0, 8(RSP) MOVD ·threadentry_call(SB), R26 MOVD (R26), R2 CALL (R2) MOVD $0, R0 // TODO: get the return value from threadentry RET TEXT ·call5(SB), NOSPLIT, $0-0 MOVD fn+0(FP), R6 MOVD a1+8(FP), R0 MOVD a2+16(FP), R1 MOVD a3+24(FP), R2 MOVD a4+32(FP), R3 MOVD a5+40(FP), R4 CALL R6 MOVD R0, ret+48(FP) RET golang-github-ebitengine-purego-0.9.1/internal/fakecgo/trampolines_loong64.s000066400000000000000000000026521512124053000271600ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors //go:build !cgo && linux #include "textflag.h" #include "go_asm.h" // these trampolines map the gcc ABI to Go ABI and then calls into the Go equivalent functions. TEXT x_cgo_init_trampoline(SB), NOSPLIT, $16 MOVV R4, 8(R3) MOVV R5, 16(R3) MOVV ·x_cgo_init_call(SB), R6 MOVV (R6), R7 CALL (R7) RET TEXT x_cgo_thread_start_trampoline(SB), NOSPLIT, $8 MOVV R4, 8(R3) MOVV ·x_cgo_thread_start_call(SB), R5 MOVV (R5), R6 CALL (R6) RET TEXT x_cgo_setenv_trampoline(SB), NOSPLIT, $8 MOVV R4, 8(R3) MOVV ·x_cgo_setenv_call(SB), R5 MOVV (R5), R6 CALL (R6) RET TEXT x_cgo_unsetenv_trampoline(SB), NOSPLIT, $8 MOVV R4, 8(R3) MOVV ·x_cgo_unsetenv_call(SB), R5 MOVV (R5), R6 CALL (R6) RET TEXT x_cgo_notify_runtime_init_done_trampoline(SB), NOSPLIT, $0 CALL ·x_cgo_notify_runtime_init_done(SB) RET TEXT x_cgo_bindm_trampoline(SB), NOSPLIT, $0 CALL ·x_cgo_bindm(SB) RET // func setg_trampoline(setg uintptr, g uintptr) TEXT ·setg_trampoline(SB), NOSPLIT, $0 MOVV G+8(FP), R4 MOVV setg+0(FP), R5 CALL (R5) RET TEXT threadentry_trampoline(SB), NOSPLIT, $16 MOVV R4, 8(R3) MOVV ·threadentry_call(SB), R5 MOVV (R5), R6 CALL (R6) RET TEXT ·call5(SB), NOSPLIT, $0-0 MOVV fn+0(FP), R9 MOVV a1+8(FP), R4 MOVV a2+16(FP), R5 MOVV a3+24(FP), R6 MOVV a4+32(FP), R7 MOVV a5+40(FP), R8 CALL (R9) MOVV R4, ret+48(FP) RET golang-github-ebitengine-purego-0.9.1/internal/fakecgo/trampolines_stubs.s000066400000000000000000000041471512124053000270310ustar00rootroot00000000000000// Code generated by 'go generate' with gen.go. DO NOT EDIT. // SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) #include "textflag.h" // these stubs are here because it is not possible to go:linkname directly the C functions on darwin arm64 TEXT _malloc(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_malloc(SB) RET TEXT _free(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_free(SB) RET TEXT _setenv(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_setenv(SB) RET TEXT _unsetenv(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_unsetenv(SB) RET TEXT _sigfillset(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_sigfillset(SB) RET TEXT _nanosleep(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_nanosleep(SB) RET TEXT _abort(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_abort(SB) RET TEXT _sigaltstack(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_sigaltstack(SB) RET TEXT _pthread_attr_init(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_attr_init(SB) RET TEXT _pthread_create(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_create(SB) RET TEXT _pthread_detach(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_detach(SB) RET TEXT _pthread_sigmask(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_sigmask(SB) RET TEXT _pthread_self(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_self(SB) RET TEXT _pthread_get_stacksize_np(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_get_stacksize_np(SB) RET TEXT _pthread_attr_getstacksize(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_attr_getstacksize(SB) RET TEXT _pthread_attr_setstacksize(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_attr_setstacksize(SB) RET TEXT _pthread_attr_destroy(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_attr_destroy(SB) RET TEXT _pthread_mutex_lock(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_mutex_lock(SB) RET TEXT _pthread_mutex_unlock(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_mutex_unlock(SB) RET TEXT _pthread_cond_broadcast(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_cond_broadcast(SB) RET TEXT _pthread_setspecific(SB), NOSPLIT|NOFRAME, $0-0 JMP purego_pthread_setspecific(SB) RET golang-github-ebitengine-purego-0.9.1/internal/load/000077500000000000000000000000001512124053000224025ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/internal/load/load_unix.go000066400000000000000000000007441512124053000247200ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors //go:build darwin || freebsd || linux || netbsd package load import "github.com/ebitengine/purego" func OpenLibrary(name string) (uintptr, error) { return purego.Dlopen(name, purego.RTLD_NOW|purego.RTLD_GLOBAL) } func CloseLibrary(handle uintptr) error { return purego.Dlclose(handle) } func OpenSymbol(lib uintptr, name string) (uintptr, error) { return purego.Dlsym(lib, name) } golang-github-ebitengine-purego-0.9.1/internal/load/load_windows.go000066400000000000000000000007311512124053000254230ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors package load import ( "syscall" ) func OpenLibrary(name string) (uintptr, error) { handle, err := syscall.LoadLibrary(name) return uintptr(handle), err } func CloseLibrary(handle uintptr) error { return syscall.FreeLibrary(syscall.Handle(handle)) } func OpenSymbol(lib uintptr, name string) (uintptr, error) { return syscall.GetProcAddress(syscall.Handle(lib), name) } golang-github-ebitengine-purego-0.9.1/internal/strings/000077500000000000000000000000001512124053000231545ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/internal/strings/strings.go000066400000000000000000000017511512124053000252000ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors package strings import ( "unsafe" ) // hasSuffix tests whether the string s ends with suffix. func hasSuffix(s, suffix string) bool { return len(s) >= len(suffix) && s[len(s)-len(suffix):] == suffix } // CString converts a go string to *byte that can be passed to C code. func CString(name string) *byte { if hasSuffix(name, "\x00") { return &(*(*[]byte)(unsafe.Pointer(&name)))[0] } b := make([]byte, len(name)+1) copy(b, name) return &b[0] } // GoString copies a null-terminated char* to a Go string. func GoString(c uintptr) string { // We take the address and then dereference it to trick go vet from creating a possible misuse of unsafe.Pointer ptr := *(*unsafe.Pointer)(unsafe.Pointer(&c)) if ptr == nil { return "" } var length int for { if *(*byte)(unsafe.Add(ptr, uintptr(length))) == '\x00' { break } length++ } return string(unsafe.Slice((*byte)(ptr), length)) } golang-github-ebitengine-purego-0.9.1/is_ios.go000066400000000000000000000005751512124053000214720ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo package purego // if you are getting this error it means that you have // CGO_ENABLED=0 while trying to build for ios. // purego does not support this mode yet. // the fix is to set CGO_ENABLED=1 which will require // a C compiler. var _ = _PUREGO_REQUIRES_CGO_ON_IOS golang-github-ebitengine-purego-0.9.1/nocgo.go000066400000000000000000000024051512124053000213040ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build !cgo && (darwin || freebsd || linux || netbsd) package purego // if CGO_ENABLED=0 import fakecgo to setup the Cgo runtime correctly. // This is required since some frameworks need TLS setup the C way which Go doesn't do. // We currently don't support ios in fakecgo mode so force Cgo or fail // // The way that the Cgo runtime (runtime/cgo) works is by setting some variables found // in runtime with non-null GCC compiled functions. The variables that are replaced are // var ( // iscgo bool // in runtime/cgo.go // _cgo_init unsafe.Pointer // in runtime/cgo.go // _cgo_thread_start unsafe.Pointer // in runtime/cgo.go // _cgo_notify_runtime_init_done unsafe.Pointer // in runtime/cgo.go // _cgo_setenv unsafe.Pointer // in runtime/env_posix.go // _cgo_unsetenv unsafe.Pointer // in runtime/env_posix.go // ) // importing fakecgo will set these (using //go:linkname) with functions written // entirely in Go (except for some assembly trampolines to change GCC ABI to Go ABI). // Doing so makes it possible to build applications that call into C without CGO_ENABLED=1. import _ "github.com/ebitengine/purego/internal/fakecgo" golang-github-ebitengine-purego-0.9.1/objc/000077500000000000000000000000001512124053000205645ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/objc/objc_block_darwin.go000066400000000000000000000214241512124053000245510ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors package objc import ( "fmt" "reflect" "sync" "unsafe" "github.com/ebitengine/purego" ) const ( // The end-goal of these defaults is to get an Objective-C memory-managed block object // that won't try to free() a Go pointer, but will call our custom blockFunctionCache.Delete() // when the reference count drops to zero, so the associated function is also unreferenced. // blockBaseClass is the name of the class that block objects will be initialized with. blockBaseClass = "__NSMallocBlock__" // blockFlags is the set of flags that block objects will be initialized with. blockFlags = blockHasCopyDispose | blockHasSignature // blockHasCopyDispose is a flag that tells the Objective-C runtime the block exports Copy and/or Dispose helpers. blockHasCopyDispose = 1 << 25 // blockHasSignature is a flag that tells the Objective-C runtime the block exports a function signature. blockHasSignature = 1 << 30 ) // blockDescriptor is the Go representation of an Objective-C block descriptor. // It is a component to be referenced by blockDescriptor. // // The layout of this struct matches Block_literal_1 described in https://clang.llvm.org/docs/Block-ABI-Apple.html#high-level type blockDescriptor struct { _ uintptr size uintptr _ uintptr dispose uintptr signature *uint8 } // blockLayout is the Go representation of the structure abstracted by a block pointer. // From the Objective-C point of view, a pointer to this struct is equivalent to an ID that // references a block. // // The layout of this struct matches __block_literal_1 described in https://clang.llvm.org/docs/Block-ABI-Apple.html#high-level type blockLayout struct { isa Class flags uint32 _ uint32 invoke uintptr descriptor *blockDescriptor } // blockFunctionCache is a thread safe cache of block layouts. // // The function closures themselves are kept alive by caching them internally until the Objective-C runtime indicates that // they can be released (presumably when the reference count reaches zero). This approach is used instead of appending the function // object to the block allocation, where it is out of the visible domain of Go's GC. type blockFunctionCache struct { mutex sync.RWMutex functions map[Block]reflect.Value } // Load retrieves a function (in the form of a reflect.Value, so Call can be invoked) associated with the key Block. func (b *blockFunctionCache) Load(key Block) reflect.Value { b.mutex.RLock() defer b.mutex.RUnlock() return b.functions[key] } // Store associates a function (in the form of a reflect.Value) with the key Block. func (b *blockFunctionCache) Store(key Block, value reflect.Value) Block { b.mutex.Lock() defer b.mutex.Unlock() b.functions[key] = value return key } // Delete removed the function associated with the key Block. func (b *blockFunctionCache) Delete(key Block) { b.mutex.Lock() defer b.mutex.Unlock() delete(b.functions, key) } // newBlockFunctionCache initializes a new blockFunctionCache func newBlockFunctionCache() *blockFunctionCache { return &blockFunctionCache{functions: map[Block]reflect.Value{}} } // blockCache is a thread safe cache of block layouts. // // It takes advantage of the block being the first argument of a block call being the block closure, // only invoking [github.com/ebitengine/purego.NewCallback] when it encounters a new function type (rather than on for every block creation). // This should mitigate block creations putting pressure on the callback limit. type blockCache struct { sync.Mutex descriptorTemplate blockDescriptor layoutTemplate blockLayout layouts map[reflect.Type]blockLayout Functions *blockFunctionCache } // encode returns a blocks type as if it was given to @encode(typ) func (*blockCache) encode(typ reflect.Type) *uint8 { // this algorithm was copied from encodeFunc, // but altered to panic on error, and to only accept a block-type signature. if typ == nil || typ.Kind() != reflect.Func { panic("objc: not a function") } var encoding string switch typ.NumOut() { case 0: encoding = encVoid default: returnType, err := encodeType(typ.Out(0), false) if err != nil { panic(fmt.Sprintf("objc: %v", err)) } encoding = returnType } if typ.NumIn() == 0 || typ.In(0) != reflect.TypeOf(Block(0)) { panic(fmt.Sprintf("objc: A Block implementation must take a Block as its first argument; got %v", typ.String())) } encoding += encId for i := 1; i < typ.NumIn(); i++ { argType, err := encodeType(typ.In(i), false) if err != nil { panic(fmt.Sprintf("objc: %v", err)) } encoding = fmt.Sprint(encoding, argType) } // return the encoding as a C-style string. return &append([]uint8(encoding), 0)[0] } // getLayout retrieves a blockLayout VALUE constructed with the supplied function type. // It will panic if the type is not a valid block function. func (b *blockCache) getLayout(typ reflect.Type) blockLayout { b.Lock() defer b.Unlock() // return the cached layout, if it exists. if layout, ok := b.layouts[typ]; ok { return layout } // otherwise: create a layout, and populate it with the default templates layout := b.layoutTemplate layout.descriptor = &blockDescriptor{} *layout.descriptor = b.descriptorTemplate // getting the signature now will panic on invalid types before we invest in creating a callback. layout.descriptor.signature = b.encode(typ) // create a global callback. // this single callback can dispatch to any function with the same signature, // since the user-provided functions are associated with the actual block allocations. layout.invoke = purego.NewCallback( reflect.MakeFunc( typ, func(args []reflect.Value) (results []reflect.Value) { return b.Functions.Load(args[0].Interface().(Block)).Call(args) }, ).Interface(), ) // store it and return it b.layouts[typ] = layout return layout } // newBlockCache initializes a block cache. // It should not be called until AFTER libobjc is fully initialized. func newBlockCache() *blockCache { cache := &blockCache{ descriptorTemplate: blockDescriptor{ size: unsafe.Sizeof(blockLayout{}), }, layoutTemplate: blockLayout{ isa: GetClass(blockBaseClass), flags: blockFlags, }, layouts: map[reflect.Type]blockLayout{}, Functions: newBlockFunctionCache(), } cache.descriptorTemplate.dispose = purego.NewCallback(cache.Functions.Delete) return cache } // theBlocksCache is the global block cache var theBlocksCache *blockCache // Block is an opaque pointer to an Objective-C object containing a function with its associated closure. type Block ID // Copy creates a copy of a block on the Objective-C heap (or increments the reference count if already on the heap). // Use [Block.Release] to free the copy when it is no longer in use. func (b Block) Copy() Block { return _Block_copy(b) } // Invoke calls the implementation of a block. func (b Block) Invoke(args ...any) { fn := theBlocksCache.Functions.Load(b) reflectedArgs := make([]reflect.Value, len(args)+1) reflectedArgs[0] = reflect.ValueOf(b) for i := range args { reflectedArgs[i+1] = reflect.ValueOf(args[i]) } fn.Call(reflectedArgs) } // Release decrements the Block's reference count, and if it is the last reference, frees it. func (b Block) Release() { _Block_release(b) } // NewBlock takes a Go function that takes a Block as its first argument. // It returns an Block that can be called by Objective-C code. // The function panics if an error occurs. // Use [Block.Release] to free this block when it is no longer in use. func NewBlock(fn any) Block { // get or create a block layout for the callback. layout := theBlocksCache.getLayout(reflect.TypeOf(fn)) // we created the layout in Go memory, so we'll copy it to a newly-created Objective-C object. block := Block(unsafe.Pointer(&layout)).Copy() // associate the fn with the block we created before returning it. return theBlocksCache.Functions.Store(block, reflect.ValueOf(fn)) } // InvokeBlock is a convenience method for calling the implementation of a block. // The block implementation must return 1 value. func InvokeBlock[T any](block Block, args ...any) (result T, err error) { block = block.Copy() defer block.Release() fn := theBlocksCache.Functions.Load(block) if fn.Type().NumIn() != len(args)+1 { return result, fmt.Errorf("objc: block callback expects %d arguments, got %d", fn.Type().NumIn()-1, len(args)) } reflectedArgs := make([]reflect.Value, len(args)+1) reflectedArgs[0] = reflect.ValueOf(block) for i := range args { reflectedArgs[i+1] = reflect.ValueOf(args[i]) } callResult := fn.Call(reflectedArgs) var ok bool result, ok = callResult[0].Interface().(T) if !ok { return result, fmt.Errorf("objc: the returned value type %s was not %T", callResult[0].Type().String(), result) } return result, nil } golang-github-ebitengine-purego-0.9.1/objc/objc_block_darwin_test.go000066400000000000000000000066261512124053000256170ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors package objc_test import ( "fmt" "testing" "github.com/ebitengine/purego" "github.com/ebitengine/purego/objc" ) func ExampleNewBlock() { _, err := purego.Dlopen("/System/Library/Frameworks/Foundation.framework/Foundation", purego.RTLD_GLOBAL|purego.RTLD_NOW) if err != nil { panic(err) } var count = 0 block := objc.NewBlock( func(block objc.Block, line objc.ID, stop *bool) { count++ fmt.Printf("LINE %d: %s\n", count, objc.Send[string](line, objc.RegisterName("UTF8String"))) *stop = count == 3 }, ) defer block.Release() lines := objc.ID(objc.GetClass("NSString")).Send(objc.RegisterName("stringWithUTF8String:"), "Alpha\nBeta\nGamma\nDelta\nEpsilon") defer lines.Send(objc.RegisterName("release")) lines.Send(objc.RegisterName("enumerateLinesUsingBlock:"), block) // Output: // LINE 1: Alpha // LINE 2: Beta // LINE 3: Gamma } func ExampleInvokeBlock() { type vector struct { X, Y, Z float64 } block := objc.NewBlock( func(block objc.Block, v1, v2 *vector) *vector { return &vector{ X: v1.Y*v2.Z - v1.Z*v2.Y, Y: v1.Z*v2.X - v1.X*v2.Z, Z: v1.X*v2.Y - v1.Y*v2.X, } }, ) defer block.Release() result, err := objc.InvokeBlock[*vector]( block, &vector{X: 0.1, Y: 2.3, Z: 4.5}, &vector{X: 6.7, Y: 8.9, Z: 0.1}, ) fmt.Println(*result, err) // Output: {-39.82 30.14 -14.52} } func TestInvoke(t *testing.T) { t.Run("return an error when passing an invalid number of arguments", func(t *testing.T) { block := objc.NewBlock(func(_ objc.Block, a int32, b int32) int32 { return a + b }) defer block.Release() if _, err := objc.InvokeBlock[int32](block, int32(8)); err == nil { t.Fatal(err) } }) t.Run("return an error when passing an invalid return type", func(t *testing.T) { block := objc.NewBlock(func(_ objc.Block, a int32, b int32) int32 { return a + b }) defer block.Release() if _, err := objc.InvokeBlock[string](block, int32(8), int32(2)); err == nil { t.Fatal(err) } }) t.Run("add two int32's and returns the result", func(t *testing.T) { block := objc.NewBlock(func(_ objc.Block, a int32, b int32) int32 { return a + b }) defer block.Release() result, err := objc.InvokeBlock[int32](block, int32(8), int32(2)) if err != nil { t.Fatal(err) } if result != 10 { t.Fatalf("expected 10, got %d", result) } }) t.Run("add two int32's and store the result in a variable", func(t *testing.T) { var result int32 block := objc.NewBlock(func(_ objc.Block, a int32, b int32) { result = a + b }) defer block.Release() block.Invoke(int32(8), int32(2)) if result != 10 { t.Fatalf("expected 10, got %d", result) } }) } func TestBlockCopyAndBlockRelease(t *testing.T) { t.Parallel() var refCount int block := objc.NewBlock( func(objc.Block) { refCount++ }, ) defer block.Release() refCount++ copies := make([]objc.Block, 17) copies[0] = block for index := 1; index < len(copies); index++ { if refCount != index { t.Fatalf("refCount: %d != %d", refCount, index) } copies[index] = copies[index-1].Copy() if copies[index] != block { t.Fatalf("Block.Copy(): %v != %v", copies[index], block) } copies[index].Invoke() } for _, copy := range copies[1:] { copy.Release() refCount-- } refCount-- block.Invoke() if refCount != 1 { t.Fatalf("refCount: %d != 1", refCount) } } golang-github-ebitengine-purego-0.9.1/objc/objc_runtime_darwin.go000066400000000000000000000633161512124053000251500ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors // Package objc is a low-level pure Go objective-c runtime. This package is easy to use incorrectly, so it is best // to use a wrapper that provides the functionality you need in a safer way. package objc import ( "errors" "fmt" "math" "reflect" "regexp" "runtime" "unicode" "unsafe" "github.com/ebitengine/purego" "github.com/ebitengine/purego/internal/strings" ) // TODO: support try/catch? // https://stackoverflow.com/questions/7062599/example-of-how-objective-cs-try-catch-implementation-is-executed-at-runtime var ( objc_msgSend_fn uintptr objc_msgSend_stret_fn uintptr objc_msgSend func(obj ID, cmd SEL, args ...any) ID objc_msgSendSuper2_fn uintptr objc_msgSendSuper2_stret_fn uintptr objc_msgSendSuper2 func(super *objc_super, cmd SEL, args ...any) ID objc_getClass func(name string) Class objc_getProtocol func(name string) *Protocol objc_allocateProtocol func(name string) *Protocol objc_registerProtocol func(protocol *Protocol) objc_allocateClassPair func(super Class, name string, extraBytes uintptr) Class objc_registerClassPair func(class Class) sel_registerName func(name string) SEL class_getSuperclass func(class Class) Class class_getInstanceVariable func(class Class, name string) Ivar class_getInstanceSize func(class Class) uintptr class_addMethod func(class Class, name SEL, imp IMP, types string) bool class_addIvar func(class Class, name string, size uintptr, alignment uint8, types string) bool class_addProtocol func(class Class, protocol *Protocol) bool ivar_getOffset func(ivar Ivar) uintptr ivar_getName func(ivar Ivar) string object_getClass func(obj ID) Class object_getIvar func(obj ID, ivar Ivar) ID object_setIvar func(obj ID, ivar Ivar, value ID) protocol_getName func(protocol *Protocol) string protocol_isEqual func(p *Protocol, p2 *Protocol) bool protocol_addMethodDescription func(p *Protocol, name SEL, types string, isRequiredMethod bool, isInstanceMethod bool) protocol_copyMethodDescriptionList func(p *Protocol, isRequiredMethod bool, isInstanceMethod bool, outCount *uint32) *MethodDescription protocol_copyProtocolList func(p *Protocol, outCount *uint32) **Protocol protocol_copyPropertyList2 func(p *Protocol, outCount *uint32, isRequiredProperty, isInstanceProperty bool) *Property protocol_addProtocol func(p *Protocol, p2 *Protocol) protocol_addProperty func(p *Protocol, name string, attributes []PropertyAttribute, attributeCount uint32, isRequiredProperty bool, isInstanceProperty bool) property_getName func(p Property) string property_getAttributes func(p Property) string free func(ptr unsafe.Pointer) _Block_copy func(Block) Block _Block_release func(Block) ) func init() { objc, err := purego.Dlopen("/usr/lib/libobjc.A.dylib", purego.RTLD_GLOBAL|purego.RTLD_NOW) if err != nil { panic(fmt.Errorf("objc: %w", err)) } objc_msgSend_fn, err = purego.Dlsym(objc, "objc_msgSend") if err != nil { panic(fmt.Errorf("objc: %w", err)) } if runtime.GOARCH == "amd64" { objc_msgSend_stret_fn, err = purego.Dlsym(objc, "objc_msgSend_stret") if err != nil { panic(fmt.Errorf("objc: %w", err)) } objc_msgSendSuper2_stret_fn, err = purego.Dlsym(objc, "objc_msgSendSuper2_stret") if err != nil { panic(fmt.Errorf("objc: %w", err)) } } purego.RegisterFunc(&objc_msgSend, objc_msgSend_fn) objc_msgSendSuper2_fn, err = purego.Dlsym(objc, "objc_msgSendSuper2") if err != nil { panic(fmt.Errorf("objc: %w", err)) } purego.RegisterFunc(&objc_msgSendSuper2, objc_msgSendSuper2_fn) purego.RegisterLibFunc(&object_getClass, objc, "object_getClass") purego.RegisterLibFunc(&objc_getClass, objc, "objc_getClass") purego.RegisterLibFunc(&objc_getProtocol, objc, "objc_getProtocol") purego.RegisterLibFunc(&objc_allocateProtocol, objc, "objc_allocateProtocol") purego.RegisterLibFunc(&objc_registerProtocol, objc, "objc_registerProtocol") purego.RegisterLibFunc(&objc_allocateClassPair, objc, "objc_allocateClassPair") purego.RegisterLibFunc(&objc_registerClassPair, objc, "objc_registerClassPair") purego.RegisterLibFunc(&sel_registerName, objc, "sel_registerName") purego.RegisterLibFunc(&class_getSuperclass, objc, "class_getSuperclass") purego.RegisterLibFunc(&class_getInstanceVariable, objc, "class_getInstanceVariable") purego.RegisterLibFunc(&class_addMethod, objc, "class_addMethod") purego.RegisterLibFunc(&class_addIvar, objc, "class_addIvar") purego.RegisterLibFunc(&class_addProtocol, objc, "class_addProtocol") purego.RegisterLibFunc(&class_getInstanceSize, objc, "class_getInstanceSize") purego.RegisterLibFunc(&ivar_getOffset, objc, "ivar_getOffset") purego.RegisterLibFunc(&ivar_getName, objc, "ivar_getName") purego.RegisterLibFunc(&protocol_getName, objc, "protocol_getName") purego.RegisterLibFunc(&protocol_isEqual, objc, "protocol_isEqual") purego.RegisterLibFunc(&protocol_addMethodDescription, objc, "protocol_addMethodDescription") purego.RegisterLibFunc(&protocol_copyMethodDescriptionList, objc, "protocol_copyMethodDescriptionList") purego.RegisterLibFunc(&protocol_copyProtocolList, objc, "protocol_copyProtocolList") purego.RegisterLibFunc(&protocol_addProtocol, objc, "protocol_addProtocol") purego.RegisterLibFunc(&protocol_addProperty, objc, "protocol_addProperty") purego.RegisterLibFunc(&protocol_copyPropertyList2, objc, "protocol_copyPropertyList2") purego.RegisterLibFunc(&property_getName, objc, "property_getName") purego.RegisterLibFunc(&property_getAttributes, objc, "property_getAttributes") purego.RegisterLibFunc(&object_getIvar, objc, "object_getIvar") purego.RegisterLibFunc(&object_setIvar, objc, "object_setIvar") purego.RegisterLibFunc(&free, purego.RTLD_DEFAULT, "free") purego.RegisterLibFunc(&_Block_copy, objc, "_Block_copy") purego.RegisterLibFunc(&_Block_release, objc, "_Block_release") theBlocksCache = newBlockCache() } // ID is an opaque pointer to some Objective-C object type ID uintptr // Class returns the class of the object. func (id ID) Class() Class { return object_getClass(id) } // Send is a convenience method for sending messages to objects. This function takes a SEL // instead of a string since RegisterName grabs the global Objective-C lock. It is best to cache the result // of RegisterName. func (id ID) Send(sel SEL, args ...any) ID { return objc_msgSend(id, sel, args...) } // GetIvar reads the value of an instance variable in an object. func (id ID) GetIvar(ivar Ivar) ID { return object_getIvar(id, ivar) } // SetIvar sets the value of an instance variable in an object. func (id ID) SetIvar(ivar Ivar, value ID) { object_setIvar(id, ivar, value) } // keep in sync with func.go const maxRegAllocStructSize = 16 // Send is a convenience method for sending messages to objects that can return any type. // This function takes a SEL instead of a string since RegisterName grabs the global Objective-C lock. // It is best to cache the result of RegisterName. func Send[T any](id ID, sel SEL, args ...any) T { var fn func(id ID, sel SEL, args ...any) T var zero T if runtime.GOARCH == "amd64" && reflect.ValueOf(zero).Kind() == reflect.Struct && reflect.ValueOf(zero).Type().Size() > maxRegAllocStructSize { purego.RegisterFunc(&fn, objc_msgSend_stret_fn) } else { purego.RegisterFunc(&fn, objc_msgSend_fn) } return fn(id, sel, args...) } // objc_super data structure is generated by the Objective-C compiler when it encounters the super keyword // as the receiver of a message. It specifies the class definition of the particular superclass that should // be messaged. type objc_super struct { receiver ID superClass Class } // SendSuper is a convenience method for sending message to object's super. This function takes a SEL // instead of a string since RegisterName grabs the global Objective-C lock. It is best to cache the result // of RegisterName. func (id ID) SendSuper(sel SEL, args ...any) ID { super := &objc_super{ receiver: id, superClass: id.Class(), } return objc_msgSendSuper2(super, sel, args...) } // SendSuper is a convenience method for sending message to object's super that can return any type. // This function takes a SEL instead of a string since RegisterName grabs the global Objective-C lock. // It is best to cache the result of RegisterName. func SendSuper[T any](id ID, sel SEL, args ...any) T { super := &objc_super{ receiver: id, superClass: id.Class(), } var fn func(objcSuper *objc_super, sel SEL, args ...any) T var zero T if runtime.GOARCH == "amd64" && reflect.ValueOf(zero).Kind() == reflect.Struct && reflect.ValueOf(zero).Type().Size() > maxRegAllocStructSize { purego.RegisterFunc(&fn, objc_msgSendSuper2_stret_fn) } else { purego.RegisterFunc(&fn, objc_msgSendSuper2_fn) } return fn(super, sel, args...) } // SEL is an opaque type that represents a method selector type SEL uintptr // RegisterName registers a method with the Objective-C runtime system, maps the method name to a selector, // and returns the selector value. This function grabs the global Objective-c lock. It is best the cache the // result of this function. func RegisterName(name string) SEL { return sel_registerName(name) } // Class is an opaque type that represents an Objective-C class. type Class uintptr // GetClass returns the Class object for the named class, or nil if the class is not registered with the Objective-C runtime. func GetClass(name string) Class { return objc_getClass(name) } // MethodDef represents the Go function and the selector that ObjC uses to access that function. type MethodDef struct { Cmd SEL Fn any } // IvarAttrib is the attribute that an ivar has. It affects if and which methods are automatically // generated when creating a class with RegisterClass. See [Apple Docs] for an understanding of these attributes. // The fields are still accessible using objc.GetIvar and objc.SetIvar regardless of the value of IvarAttrib. // // Take for example this Objective-C code: // // @property (readwrite) float value; // // In Go, the functions can be accessed as followed: // // var value = purego.Send[float32](id, purego.RegisterName("value")) // id.Send(purego.RegisterName("setValue:"), 3.46) // // [Apple Docs]: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ObjectiveC/Chapters/ocProperties.html type IvarAttrib int const ( ReadOnly IvarAttrib = 1 << iota ReadWrite ) // FieldDef is a definition of a field to add to an Objective-C class. // The name of the field is what will be used to access it through the Ivar. If the type is bool // the name cannot start with `is` since a getter will be generated with the name `isBoolName`. // The name also cannot contain any spaces. // The type is the Go equivalent type of the Ivar. // Attribute determines if a getter and or setter method is generated for this field. type FieldDef struct { Name string Type reflect.Type Attribute IvarAttrib } // ivarRegex checks to make sure the Ivar is correctly formatted var ivarRegex = regexp.MustCompile("[a-z_][a-zA-Z0-9_]*") // RegisterClass takes the name of the class to create, the superclass, a list of protocols this class // implements, a list of fields this class has and a list of methods. It returns the created class or an error // describing what went wrong. func RegisterClass(name string, superClass Class, protocols []*Protocol, ivars []FieldDef, methods []MethodDef) (Class, error) { class := objc_allocateClassPair(superClass, name, 0) if class == 0 { return 0, fmt.Errorf("objc: failed to create class with name '%s'", name) } // Add Protocols for _, p := range protocols { if !class.AddProtocol(p) { return 0, fmt.Errorf("objc: couldn't add Protocol %s", protocol_getName(p)) } } // Add exported methods based on the selectors returned from ClassDef(string) SEL for idx, def := range methods { imp, err := func() (imp IMP, err error) { defer func() { if r := recover(); r != nil { err = fmt.Errorf("objc: failed to create IMP: %s", r) } }() return NewIMP(def.Fn), nil }() if err != nil { return 0, fmt.Errorf("objc: couldn't add Method at index %d: %w", idx, err) } encoding, err := encodeFunc(def.Fn) if err != nil { return 0, fmt.Errorf("objc: couldn't add Method at index %d: %w", idx, err) } if !class.AddMethod(def.Cmd, imp, encoding) { return 0, fmt.Errorf("objc: couldn't add Method at index %d", idx) } } // Add Ivars for _, instVar := range ivars { ivar := instVar if !ivarRegex.MatchString(ivar.Name) { return 0, fmt.Errorf("objc: Ivar must start with a lowercase letter and only contain ASCII letters and numbers: '%s'", ivar.Name) } size := ivar.Type.Size() alignment := uint8(math.Log2(float64(ivar.Type.Align()))) enc, err := encodeType(ivar.Type, false) if err != nil { return 0, fmt.Errorf("objc: couldn't add Ivar %s: %w", ivar.Name, err) } if !class_addIvar(class, ivar.Name, size, alignment, enc) { return 0, fmt.Errorf("objc: couldn't add Ivar %s", ivar.Name) } offset := class.InstanceVariable(ivar.Name).Offset() switch ivar.Attribute { case ReadWrite: ty := reflect.FuncOf( []reflect.Type{ reflect.TypeOf(ID(0)), reflect.TypeOf(SEL(0)), ivar.Type, }, nil, false, ) var encoding string if encoding, err = encodeFunc(reflect.New(ty).Elem().Interface()); err != nil { return 0, fmt.Errorf("objc: failed to create read method for '%s': %w", ivar.Name, err) } val := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) { // on entry the first and second arguments are ID and SEL followed by the value if len(args) != 3 { panic(fmt.Sprintf("objc: incorrect number of args. expected 3 got %d", len(args))) } // The following reflect code does the equivalent of this: // // ((*struct { // Padding [offset]byte // Value int // })(unsafe.Pointer(args[0].Interface().(ID)))).v = 123 // // However, since the type of the variable is unknown reflection is used to actually assign the value id := args[0].Interface().(ID) ptr := *(*unsafe.Pointer)(unsafe.Pointer(&id)) // circumvent go vet reflect.NewAt(ivar.Type, unsafe.Add(ptr, offset)).Elem().Set(args[2]) return nil }).Interface() // this code only works for ascii but that shouldn't be a problem selector := "set" + string(unicode.ToUpper(rune(ivar.Name[0]))) + ivar.Name[1:] + ":\x00" class.AddMethod(RegisterName(selector), NewIMP(val), encoding) fallthrough // also implement the read method case ReadOnly: ty := reflect.FuncOf( []reflect.Type{ reflect.TypeOf(ID(0)), reflect.TypeOf(SEL(0)), }, []reflect.Type{ivar.Type}, false, ) var encoding string if encoding, err = encodeFunc(reflect.New(ty).Elem().Interface()); err != nil { return 0, fmt.Errorf("objc: failed to create read method for '%s': %w", ivar.Name, err) } val := reflect.MakeFunc(ty, func(args []reflect.Value) (results []reflect.Value) { // on entry the first and second arguments are ID and SEL if len(args) != 2 { panic(fmt.Sprintf("objc: incorrect number of args. expected 2 got %d", len(args))) } id := args[0].Interface().(ID) ptr := *(*unsafe.Pointer)(unsafe.Pointer(&id)) // circumvent go vet // the variable is located at an offset from the id return []reflect.Value{reflect.NewAt(ivar.Type, unsafe.Add(ptr, offset)).Elem()} }).Interface() if ivar.Type.Kind() == reflect.Bool { // this code only works for ascii but that shouldn't be a problem ivar.Name = "is" + string(unicode.ToUpper(rune(ivar.Name[0]))) + ivar.Name[1:] } class.AddMethod(RegisterName(ivar.Name), NewIMP(val), encoding) default: return 0, fmt.Errorf("objc: unknown Ivar Attribute (%d)", ivar.Attribute) } } objc_registerClassPair(class) return class, nil } const ( encId = "@" encClass = "#" encSelector = ":" encChar = "c" encUChar = "C" encShort = "s" encUShort = "S" encInt = "i" encUInt = "I" encLong = "l" encULong = "L" encFloat = "f" encDouble = "d" encBool = "B" encVoid = "v" encPtr = "^" encCharPtr = "*" encStructBegin = "{" encStructEnd = "}" encUnsafePtr = "^v" ) // encodeType returns a string representing a type as if it was given to @encode(typ) // Source: https://developer.apple.com/library/archive/documentation/Cocoa/Conceptual/ObjCRuntimeGuide/Articles/ocrtTypeEncodings.html#//apple_ref/doc/uid/TP40008048-CH100 func encodeType(typ reflect.Type, insidePtr bool) (string, error) { switch typ { case reflect.TypeOf(Class(0)): return encClass, nil case reflect.TypeOf(ID(0)), reflect.TypeOf(Block(0)): return encId, nil case reflect.TypeOf(SEL(0)): return encSelector, nil } kind := typ.Kind() switch kind { case reflect.Bool: return encBool, nil case reflect.Int: return encLong, nil case reflect.Int8: return encChar, nil case reflect.Int16: return encShort, nil case reflect.Int32: return encInt, nil case reflect.Int64: return encULong, nil case reflect.Uint: return encULong, nil case reflect.Uint8: return encUChar, nil case reflect.Uint16: return encUShort, nil case reflect.Uint32: return encUInt, nil case reflect.Uint64: return encULong, nil case reflect.Uintptr: return encPtr, nil case reflect.Float32: return encFloat, nil case reflect.Float64: return encDouble, nil case reflect.Ptr: enc, err := encodeType(typ.Elem(), true) return encPtr + enc, err case reflect.Struct: if insidePtr { return encStructBegin + typ.Name() + encStructEnd, nil } encoding := encStructBegin encoding += typ.Name() encoding += "=" for i := 0; i < typ.NumField(); i++ { f := typ.Field(i) tmp, err := encodeType(f.Type, false) if err != nil { return "", err } encoding += tmp } encoding += encStructEnd return encoding, nil case reflect.UnsafePointer: return encUnsafePtr, nil case reflect.String: return encCharPtr, nil } return "", errors.New(fmt.Sprintf("unhandled/invalid kind %v typed %v", kind, typ)) } // encodeFunc returns a functions type as if it was given to @encode(fn) func encodeFunc(fn any) (string, error) { typ := reflect.TypeOf(fn) if typ.Kind() != reflect.Func { return "", errors.New("not a func") } encoding := "" switch typ.NumOut() { case 0: encoding += encVoid case 1: tmp, err := encodeType(typ.Out(0), false) if err != nil { return "", err } encoding += tmp default: return "", errors.New("too many output parameters") } if typ.NumIn() < 2 { return "", errors.New("func doesn't take ID and SEL as its first two parameters") } encoding += encId for i := 1; i < typ.NumIn(); i++ { tmp, err := encodeType(typ.In(i), false) if err != nil { return "", err } encoding += tmp } return encoding, nil } // SuperClass returns the superclass of a class. // You should usually use NSObject‘s superclass method instead of this function. func (c Class) SuperClass() Class { return class_getSuperclass(c) } // AddMethod adds a new method to a class with a given name and implementation. // The types argument is a string containing the mapping of parameters and return type. // Since the function must take at least two arguments—self and _cmd, the second and third // characters must be “@:” (the first character is the return type). func (c Class) AddMethod(name SEL, imp IMP, types string) bool { return class_addMethod(c, name, imp, types) } // AddProtocol adds a protocol to a class. // Returns true if the protocol was added successfully, otherwise false (for example, // the class already conforms to that protocol). func (c Class) AddProtocol(protocol *Protocol) bool { return class_addProtocol(c, protocol) } // InstanceSize returns the size in bytes of instances of the class or 0 if cls is nil func (c Class) InstanceSize() uintptr { return class_getInstanceSize(c) } // InstanceVariable returns an Ivar data structure containing information about the instance variable specified by name. func (c Class) InstanceVariable(name string) Ivar { return class_getInstanceVariable(c, name) } // Ivar an opaque type that represents an instance variable. type Ivar uintptr // Offset returns the offset of an instance variable that can be used to assign and read the Ivar's value. // // For instance variables of type ID or other object types, call Ivar and SetIvar instead // of using this offset to access the instance variable data directly. func (i Ivar) Offset() uintptr { return ivar_getOffset(i) } func (i Ivar) Name() string { return ivar_getName(i) } // MethodDescription holds the name and type definition of a method. type MethodDescription struct { name, types uintptr } // Name returns the name of this method. func (m MethodDescription) Name() string { return strings.GoString(m.name) } // Types returns the OBJC runtime encoded type description. func (m MethodDescription) Types() string { return strings.GoString(m.types) } // PropertyAttribute contains the null-terminated Name and Value pair of a Properties internal description. type PropertyAttribute struct { Name, Value *byte } // Property is an opaque type for Objective-C property metadata. type Property uintptr // Name returns the name of this property. func (p Property) Name() string { return property_getName(p) } // Attributes returns a comma separated list of PropertyAttribute func (p Property) Attributes() string { return property_getAttributes(p) } // Protocol is a type that declares methods that can be implemented by any class. type Protocol [0]func() // GetProtocol returns the protocol for the given name or nil if there is no protocol by that name. func GetProtocol(name string) *Protocol { return objc_getProtocol(name) } // AllocateProtocol creates a new protocol in the OBJC runtime or nil if the protocol already exists. func AllocateProtocol(name string) *Protocol { return objc_allocateProtocol(name) } // Register registers the protocol created using AllocateProtocol with the runtime. This must be done // before it is used anywhere and can only be called once. func (p *Protocol) Register() { objc_registerProtocol(p) } // CopyMethodDescriptionList returns a list of methods that this protocol has given it isRequiredMethod and isInstanceMethod. func (p *Protocol) CopyMethodDescriptionList(isRequiredMethod, isInstanceMethod bool) []MethodDescription { count := uint32(0) desc := protocol_copyMethodDescriptionList(p, isRequiredMethod, isInstanceMethod, &count) methods := clone(unsafe.Slice(desc, count)) free(unsafe.Pointer(desc)) return methods } // CopyProtocolList returns a list of the protocols that this protocol inherits from. func (p *Protocol) CopyProtocolList() []*Protocol { count := uint32(0) desc := protocol_copyProtocolList(p, &count) protocols := clone(unsafe.Slice(desc, count)) free(unsafe.Pointer(desc)) return protocols } // CopyPropertyList returns a list of properties that this protocol has given it isRequiredProperty and isInstanceProperty. func (p *Protocol) CopyPropertyList(isRequiredProperty, isInstanceProperty bool) []Property { count := uint32(0) desc := protocol_copyPropertyList2(p, &count, isRequiredProperty, isInstanceProperty) protocols := clone(unsafe.Slice(desc, count)) free(unsafe.Pointer(desc)) return protocols } // Name returns the name of this protocol. func (p *Protocol) Name() string { return protocol_getName(p) } // Equals return true if the two protocols are the same. func (p *Protocol) Equals(p2 *Protocol) bool { return protocol_isEqual(p, p2) } // AddMethodDescription adds a method to a protocol. This can only be called between AllocateProtocol and Protocol.Register. func (p *Protocol) AddMethodDescription(name SEL, types string, isRequiredMethod, isInstanceMethod bool) { protocol_addMethodDescription(p, name, types, isRequiredMethod, isInstanceMethod) } // AddProtocol marks the protocol as inheriting from another. This can only be called between AllocateProtocol and Protocol.Register. func (p *Protocol) AddProtocol(protocol *Protocol) { protocol_addProtocol(p, protocol) } // AddProperty adds a property to the protocol. This can only be called between AllocateProtocol and Protocol.Register. func (p *Protocol) AddProperty(name string, attributes []PropertyAttribute, isRequiredProperty, isInstanceProperty bool) { protocol_addProperty(p, name, attributes, uint32(len(attributes)), isRequiredProperty, isInstanceProperty) } // IMP is a function pointer that can be called by Objective-C code. type IMP uintptr // NewIMP takes a Go function that takes (ID, SEL) as its first two arguments. // It returns an IMP function pointer that can be called by Objective-C code. // The function panics if an error occurs. // The function pointer is never deallocated. func NewIMP(fn any) IMP { ty := reflect.TypeOf(fn) if ty.Kind() != reflect.Func { panic("objc: not a function") } // IMP is stricter than a normal callback // id (*IMP)(id, SEL, ...) switch { case ty.NumIn() < 2: fallthrough case ty.In(0) != reflect.TypeOf(ID(0)): fallthrough case ty.In(1) != reflect.TypeOf(SEL(0)): panic("objc: NewIMP must take a (id, SEL) as its first two arguments; got " + ty.String()) } return IMP(purego.NewCallback(fn)) } // TODO: remove and use slices.Clone when minimum version for purego is 1.21 func clone[S ~[]E, E any](s S) S { // Preserve nilness in case it matters. if s == nil { return nil } // Avoid s[:0:0] as it leads to unwanted liveness when cloning a // zero-length slice of a large array; see https://go.dev/issue/68488. return append(S{}, s...) } golang-github-ebitengine-purego-0.9.1/objc/objc_runtime_darwin_test.go000066400000000000000000000125741512124053000262070ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors package objc_test import ( "fmt" "log" "reflect" "testing" "github.com/ebitengine/purego" "github.com/ebitengine/purego/objc" ) func ExampleRegisterClass_helloworld() { class, err := objc.RegisterClass( "FooObject", objc.GetClass("NSObject"), nil, nil, []objc.MethodDef{ { Cmd: objc.RegisterName("run"), Fn: func(self objc.ID, _cmd objc.SEL) { fmt.Println("Hello World!") }, }, }, ) if err != nil { panic(err) } object := objc.ID(class).Send(objc.RegisterName("new")) object.Send(objc.RegisterName("run")) // Output: Hello World! } func ExampleRegisterClass() { var ( sel_new = objc.RegisterName("new") sel_init = objc.RegisterName("init") sel_setBar = objc.RegisterName("setBar:") sel_bar = objc.RegisterName("bar") BarInit = func(id objc.ID, cmd objc.SEL) objc.ID { return id.SendSuper(cmd) } ) class, err := objc.RegisterClass( "BarObject", objc.GetClass("NSObject"), []*objc.Protocol{ objc.GetProtocol("NSDelegateWindow"), }, []objc.FieldDef{ { Name: "bar", Type: reflect.TypeOf(int(0)), Attribute: objc.ReadWrite, }, { Name: "foo", Type: reflect.TypeOf(false), Attribute: objc.ReadWrite, }, }, []objc.MethodDef{ { Cmd: sel_init, Fn: BarInit, }, }, ) if err != nil { panic(err) } object := objc.ID(class).Send(sel_new) object.Send(sel_setBar, 123) bar := int(object.Send(sel_bar)) fmt.Println(bar) // Output: 123 } func ExampleIMP() { imp := objc.NewIMP(func(self objc.ID, _cmd objc.SEL, a3, a4, a5, a6, a7, a8, a9 int) { fmt.Println("IMP:", self, _cmd, a3, a4, a5, a6, a7, a8, a9) }) purego.SyscallN(uintptr(imp), 105, 567, 9, 2, 3, ^uintptr(4), 4, 8, 9) // Output: IMP: 105 567 9 2 3 -5 4 8 9 } func ExampleID_SendSuper() { super, err := objc.RegisterClass( "SuperObject", objc.GetClass("NSObject"), nil, nil, []objc.MethodDef{ { Cmd: objc.RegisterName("doSomething"), Fn: func(self objc.ID, _cmd objc.SEL) { fmt.Println("In Super!") }, }, }, ) if err != nil { panic(err) } child, err := objc.RegisterClass( "ChildObject", super, nil, nil, []objc.MethodDef{ { Cmd: objc.RegisterName("doSomething"), Fn: func(self objc.ID, _cmd objc.SEL) { fmt.Println("In Child") self.SendSuper(_cmd) }, }, }, ) if err != nil { panic(err) } objc.ID(child).Send(objc.RegisterName("new")).Send(objc.RegisterName("doSomething")) // Output: In Child // In Super! } func TestSend(t *testing.T) { // NSNumber comes from Foundation so make sure we have linked to that framework. _, err := purego.Dlopen("/System/Library/Frameworks/Foundation.framework/Foundation", purego.RTLD_GLOBAL|purego.RTLD_NOW) if err != nil { t.Fatal(err) } const double = float64(2.34) // Initialize a NSNumber NSNumber := objc.ID(objc.GetClass("NSNumber")).Send(objc.RegisterName("numberWithDouble:"), double) // Then get that number back using the generic Send function. number := objc.Send[float64](NSNumber, objc.RegisterName("doubleValue")) if double != number { t.Failed() } } func ExampleSend() { type NSRange struct { Location, Range uint } class_NSString := objc.GetClass("NSString") sel_stringWithUTF8String := objc.RegisterName("stringWithUTF8String:") fullString := objc.ID(class_NSString).Send(sel_stringWithUTF8String, "Hello, World!\x00") subString := objc.ID(class_NSString).Send(sel_stringWithUTF8String, "lo, Wor\x00") r := objc.Send[NSRange](fullString, objc.RegisterName("rangeOfString:"), subString) fmt.Println(r) // Output: {3 7} } func ExampleSendSuper() { super, err := objc.RegisterClass( "SuperObject2", objc.GetClass("NSObject"), nil, nil, []objc.MethodDef{ { Cmd: objc.RegisterName("doSomething"), Fn: func(self objc.ID, _cmd objc.SEL) int { return 16 }, }, }, ) if err != nil { panic(err) } child, err := objc.RegisterClass( "ChildObject2", super, nil, nil, []objc.MethodDef{ { Cmd: objc.RegisterName("doSomething"), Fn: func(self objc.ID, _cmd objc.SEL) int { return 24 }, }, }, ) if err != nil { panic(err) } res := objc.SendSuper[int](objc.ID(child).Send(objc.RegisterName("new")), objc.RegisterName("doSomething")) fmt.Println(res) // Output: 16 } func ExampleAllocateProtocol() { var p *objc.Protocol if p = objc.AllocateProtocol("MyCustomProtocol"); p != nil { p.AddMethodDescription(objc.RegisterName("isFoo"), "B16@0:8", true, true) var adoptedProtocol *objc.Protocol adoptedProtocol = objc.GetProtocol("NSObject") if adoptedProtocol == nil { log.Fatalln("protocol 'NSObject' does not exist") } p.AddProtocol(adoptedProtocol) p.AddProperty("accessibilityElement", []objc.PropertyAttribute{ {Name: &[]byte("T\x00")[0], Value: &[]byte("B\x00")[0]}, {Name: &[]byte("G\x00")[0], Value: &[]byte("isBar\x00")[0]}, }, true, true) p.Register() } p = objc.GetProtocol("MyCustomProtocol") for _, protocol := range p.CopyProtocolList() { fmt.Println(protocol.Name()) } for _, property := range p.CopyPropertyList(true, true) { fmt.Println(property.Name(), property.Attributes()) } for _, method := range p.CopyMethodDescriptionList(true, true) { fmt.Println(method.Name(), method.Types()) } // Output: // NSObject // accessibilityElement TB,GisBar // isFoo B16@0:8 } golang-github-ebitengine-purego-0.9.1/struct_amd64.go000066400000000000000000000153601512124053000225220ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors package purego import ( "math" "reflect" "unsafe" ) func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { outSize := outType.Size() switch { case outSize == 0: return reflect.New(outType).Elem() case outSize <= 8: if isAllFloats(outType) { // 2 float32s or 1 float64s are return in the float register return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{syscall.f1})).Elem() } // up to 8 bytes is returned in RAX return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{syscall.a1})).Elem() case outSize <= 16: r1, r2 := syscall.a1, syscall.a2 if isAllFloats(outType) { r1 = syscall.f1 r2 = syscall.f2 } else { // check first 8 bytes if it's floats hasFirstFloat := false f1 := outType.Field(0).Type if f1.Kind() == reflect.Float64 || f1.Kind() == reflect.Float32 && outType.Field(1).Type.Kind() == reflect.Float32 { r1 = syscall.f1 hasFirstFloat = true } // find index of the field that starts the second 8 bytes var i int for i = 0; i < outType.NumField(); i++ { if outType.Field(i).Offset == 8 { break } } // check last 8 bytes if they are floats f1 = outType.Field(i).Type if f1.Kind() == reflect.Float64 || f1.Kind() == reflect.Float32 && i+1 == outType.NumField() { r2 = syscall.f1 } else if hasFirstFloat { // if the first field was a float then that means the second integer field // comes from the first integer register r2 = syscall.a1 } } return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem() default: // create struct from the Go pointer created above // weird pointer dereference to circumvent go vet return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))).Elem() } } func isAllFloats(ty reflect.Type) bool { for i := 0; i < ty.NumField(); i++ { f := ty.Field(i) switch f.Type.Kind() { case reflect.Float64, reflect.Float32: default: return false } } return true } // https://refspecs.linuxbase.org/elf/x86_64-abi-0.99.pdf // https://gitlab.com/x86-psABIs/x86-64-ABI // Class determines where the 8 byte value goes. // Higher value classes win over lower value classes const ( _NO_CLASS = 0b0000 _SSE = 0b0001 _X87 = 0b0011 // long double not used in Go _INTEGER = 0b0111 _MEMORY = 0b1111 ) func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { if v.Type().Size() == 0 { return keepAlive } // if greater than 64 bytes place on stack if v.Type().Size() > 8*8 { placeStack(v, addStack) return keepAlive } var ( savedNumFloats = *numFloats savedNumInts = *numInts savedNumStack = *numStack ) placeOnStack := postMerger(v.Type()) || !tryPlaceRegister(v, addFloat, addInt) if placeOnStack { // reset any values placed in registers *numFloats = savedNumFloats *numInts = savedNumInts *numStack = savedNumStack placeStack(v, addStack) } return keepAlive } func postMerger(t reflect.Type) (passInMemory bool) { // (c) If the size of the aggregate exceeds two eightbytes and the first eight- byte isn’t SSE or any other // eightbyte isn’t SSEUP, the whole argument is passed in memory. if t.Kind() != reflect.Struct { return false } if t.Size() <= 2*8 { return false } return true // Go does not have an SSE/SSEUP type so this is always true } func tryPlaceRegister(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) (ok bool) { ok = true var val uint64 var shift byte // # of bits to shift var flushed bool class := _NO_CLASS flushIfNeeded := func() { if flushed { return } flushed = true if class == _SSE { addFloat(uintptr(val)) } else { addInt(uintptr(val)) } val = 0 shift = 0 class = _NO_CLASS } var place func(v reflect.Value) place = func(v reflect.Value) { var numFields int if v.Kind() == reflect.Struct { numFields = v.Type().NumField() } else { numFields = v.Type().Len() } for i := 0; i < numFields; i++ { flushed = false var f reflect.Value if v.Kind() == reflect.Struct { f = v.Field(i) } else { f = v.Index(i) } switch f.Kind() { case reflect.Struct: place(f) case reflect.Bool: if f.Bool() { val |= 1 << shift } shift += 8 class |= _INTEGER case reflect.Pointer: ok = false return case reflect.Int8: val |= uint64(f.Int()&0xFF) << shift shift += 8 class |= _INTEGER case reflect.Int16: val |= uint64(f.Int()&0xFFFF) << shift shift += 16 class |= _INTEGER case reflect.Int32: val |= uint64(f.Int()&0xFFFF_FFFF) << shift shift += 32 class |= _INTEGER case reflect.Int64, reflect.Int: val = uint64(f.Int()) shift = 64 class = _INTEGER case reflect.Uint8: val |= f.Uint() << shift shift += 8 class |= _INTEGER case reflect.Uint16: val |= f.Uint() << shift shift += 16 class |= _INTEGER case reflect.Uint32: val |= f.Uint() << shift shift += 32 class |= _INTEGER case reflect.Uint64, reflect.Uint, reflect.Uintptr: val = f.Uint() shift = 64 class = _INTEGER case reflect.Float32: val |= uint64(math.Float32bits(float32(f.Float()))) << shift shift += 32 class |= _SSE case reflect.Float64: if v.Type().Size() > 16 { ok = false return } val = uint64(math.Float64bits(f.Float())) shift = 64 class = _SSE case reflect.Array: place(f) default: panic("purego: unsupported kind " + f.Kind().String()) } if shift == 64 { flushIfNeeded() } else if shift > 64 { // Should never happen, but may if we forget to reset shift after flush (or forget to flush), // better fall apart here, than corrupt arguments. panic("purego: tryPlaceRegisters shift > 64") } } } place(v) flushIfNeeded() return ok } func placeStack(v reflect.Value, addStack func(uintptr)) { for i := 0; i < v.Type().NumField(); i++ { f := v.Field(i) switch f.Kind() { case reflect.Pointer: addStack(f.Pointer()) case reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64: addStack(uintptr(f.Int())) case reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr: addStack(uintptr(f.Uint())) case reflect.Float32: addStack(uintptr(math.Float32bits(float32(f.Float())))) case reflect.Float64: addStack(uintptr(math.Float64bits(f.Float()))) case reflect.Struct: placeStack(f, addStack) default: panic("purego: unsupported kind " + f.Kind().String()) } } } func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { panic("purego: not needed on amd64") } golang-github-ebitengine-purego-0.9.1/struct_arm64.go000066400000000000000000000173661512124053000225500ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors package purego import ( "math" "reflect" "unsafe" ) func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { outSize := outType.Size() switch { case outSize == 0: return reflect.New(outType).Elem() case outSize <= 8: r1 := syscall.a1 if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { r1 = syscall.f1 if numFields == 2 { r1 = syscall.f2<<32 | syscall.f1 } } return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{r1})).Elem() case outSize <= 16: r1, r2 := syscall.a1, syscall.a2 if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { switch numFields { case 4: r1 = syscall.f2<<32 | syscall.f1 r2 = syscall.f4<<32 | syscall.f3 case 3: r1 = syscall.f2<<32 | syscall.f1 r2 = syscall.f3 case 2: r1 = syscall.f1 r2 = syscall.f2 default: panic("unreachable") } } return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem() default: if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats && numFields <= 4 { switch numFields { case 4: return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b, c, d uintptr }{syscall.f1, syscall.f2, syscall.f3, syscall.f4})).Elem() case 3: return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b, c uintptr }{syscall.f1, syscall.f2, syscall.f3})).Elem() default: panic("unreachable") } } // create struct from the Go pointer created in arm64_r8 // weird pointer dereference to circumvent go vet return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.arm64_r8))).Elem() } } // https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst const ( _NO_CLASS = 0b00 _FLOAT = 0b01 _INT = 0b11 ) func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { if v.Type().Size() == 0 { return keepAlive } if hva, hfa, size := isHVA(v.Type()), isHFA(v.Type()), v.Type().Size(); hva || hfa || size <= 16 { // if this doesn't fit entirely in registers then // each element goes onto the stack if hfa && *numFloats+v.NumField() > numOfFloatRegisters { *numFloats = numOfFloatRegisters } else if hva && *numInts+v.NumField() > numOfIntegerRegisters() { *numInts = numOfIntegerRegisters() } placeRegisters(v, addFloat, addInt) } else { keepAlive = placeStack(v, keepAlive, addInt) } return keepAlive // the struct was allocated so don't panic } func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { var val uint64 var shift byte var flushed bool class := _NO_CLASS var place func(v reflect.Value) place = func(v reflect.Value) { var numFields int if v.Kind() == reflect.Struct { numFields = v.Type().NumField() } else { numFields = v.Type().Len() } for k := 0; k < numFields; k++ { flushed = false var f reflect.Value if v.Kind() == reflect.Struct { f = v.Field(k) } else { f = v.Index(k) } align := byte(f.Type().Align()*8 - 1) shift = (shift + align) &^ align if shift >= 64 { shift = 0 flushed = true if class == _FLOAT { addFloat(uintptr(val)) } else { addInt(uintptr(val)) } val = 0 class = _NO_CLASS } switch f.Type().Kind() { case reflect.Struct: place(f) case reflect.Bool: if f.Bool() { val |= 1 << shift } shift += 8 class |= _INT case reflect.Uint8: val |= f.Uint() << shift shift += 8 class |= _INT case reflect.Uint16: val |= f.Uint() << shift shift += 16 class |= _INT case reflect.Uint32: val |= f.Uint() << shift shift += 32 class |= _INT case reflect.Uint64, reflect.Uint, reflect.Uintptr: addInt(uintptr(f.Uint())) shift = 0 flushed = true class = _NO_CLASS case reflect.Int8: val |= uint64(f.Int()&0xFF) << shift shift += 8 class |= _INT case reflect.Int16: val |= uint64(f.Int()&0xFFFF) << shift shift += 16 class |= _INT case reflect.Int32: val |= uint64(f.Int()&0xFFFF_FFFF) << shift shift += 32 class |= _INT case reflect.Int64, reflect.Int: addInt(uintptr(f.Int())) shift = 0 flushed = true class = _NO_CLASS case reflect.Float32: if class == _FLOAT { addFloat(uintptr(val)) val = 0 shift = 0 } val |= uint64(math.Float32bits(float32(f.Float()))) << shift shift += 32 class |= _FLOAT case reflect.Float64: addFloat(uintptr(math.Float64bits(float64(f.Float())))) shift = 0 flushed = true class = _NO_CLASS case reflect.Ptr: addInt(f.Pointer()) shift = 0 flushed = true class = _NO_CLASS case reflect.Array: place(f) default: panic("purego: unsupported kind " + f.Kind().String()) } } } place(v) if !flushed { if class == _FLOAT { addFloat(uintptr(val)) } else { addInt(uintptr(val)) } } } func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any { // Struct is too big to be placed in registers. // Copy to heap and place the pointer in register ptrStruct := reflect.New(v.Type()) ptrStruct.Elem().Set(v) ptr := ptrStruct.Elem().Addr().UnsafePointer() keepAlive = append(keepAlive, ptr) addInt(uintptr(ptr)) return keepAlive } // isHFA reports a Homogeneous Floating-point Aggregate (HFA) which is a Fundamental Data Type that is a // Floating-Point type and at most four uniquely addressable members (5.9.5.1 in [Arm64 Calling Convention]). // This type of struct will be placed more compactly than the individual fields. // // [Arm64 Calling Convention]: https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst func isHFA(t reflect.Type) bool { // round up struct size to nearest 8 see section B.4 structSize := roundUpTo8(t.Size()) if structSize == 0 || t.NumField() > 4 { return false } first := t.Field(0) switch first.Type.Kind() { case reflect.Float32, reflect.Float64: firstKind := first.Type.Kind() for i := 0; i < t.NumField(); i++ { if t.Field(i).Type.Kind() != firstKind { return false } } return true case reflect.Array: switch first.Type.Elem().Kind() { case reflect.Float32, reflect.Float64: return true default: return false } case reflect.Struct: for i := 0; i < first.Type.NumField(); i++ { if !isHFA(first.Type) { return false } } return true default: return false } } // isHVA reports a Homogeneous Aggregate with a Fundamental Data Type that is a Short-Vector type // and at most four uniquely addressable members (5.9.5.2 in [Arm64 Calling Convention]). // A short vector is a machine type that is composed of repeated instances of one fundamental integral or // floating-point type. It may be 8 or 16 bytes in total size (5.4 in [Arm64 Calling Convention]). // This type of struct will be placed more compactly than the individual fields. // // [Arm64 Calling Convention]: https://github.com/ARM-software/abi-aa/blob/main/sysvabi64/sysvabi64.rst func isHVA(t reflect.Type) bool { // round up struct size to nearest 8 see section B.4 structSize := roundUpTo8(t.Size()) if structSize == 0 || (structSize != 8 && structSize != 16) { return false } first := t.Field(0) switch first.Type.Kind() { case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Int8, reflect.Int16, reflect.Int32: firstKind := first.Type.Kind() for i := 0; i < t.NumField(); i++ { if t.Field(i).Type.Kind() != firstKind { return false } } return true case reflect.Array: switch first.Type.Elem().Kind() { case reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Int8, reflect.Int16, reflect.Int32: return true default: return false } default: return false } } golang-github-ebitengine-purego-0.9.1/struct_loong64.go000066400000000000000000000107101512124053000230710ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors package purego import ( "math" "reflect" "unsafe" ) func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { outSize := outType.Size() switch { case outSize == 0: return reflect.New(outType).Elem() case outSize <= 8: r1 := syscall.a1 if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { r1 = syscall.f1 if numFields == 2 { r1 = syscall.f2<<32 | syscall.f1 } } return reflect.NewAt(outType, unsafe.Pointer(&struct{ a uintptr }{r1})).Elem() case outSize <= 16: r1, r2 := syscall.a1, syscall.a2 if isAllFloats, numFields := isAllSameFloat(outType); isAllFloats { switch numFields { case 4: r1 = syscall.f2<<32 | syscall.f1 r2 = syscall.f4<<32 | syscall.f3 case 3: r1 = syscall.f2<<32 | syscall.f1 r2 = syscall.f3 case 2: r1 = syscall.f1 r2 = syscall.f2 default: panic("unreachable") } } return reflect.NewAt(outType, unsafe.Pointer(&struct{ a, b uintptr }{r1, r2})).Elem() default: // create struct from the Go pointer created above // weird pointer dereference to circumvent go vet return reflect.NewAt(outType, *(*unsafe.Pointer)(unsafe.Pointer(&syscall.a1))).Elem() } } const ( _NO_CLASS = 0b00 _FLOAT = 0b01 _INT = 0b11 ) func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { if v.Type().Size() == 0 { return keepAlive } if size := v.Type().Size(); size <= 16 { placeRegisters(v, addFloat, addInt) } else { keepAlive = placeStack(v, keepAlive, addInt) } return keepAlive // the struct was allocated so don't panic } func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { var val uint64 var shift byte var flushed bool class := _NO_CLASS var place func(v reflect.Value) place = func(v reflect.Value) { var numFields int if v.Kind() == reflect.Struct { numFields = v.Type().NumField() } else { numFields = v.Type().Len() } for k := 0; k < numFields; k++ { flushed = false var f reflect.Value if v.Kind() == reflect.Struct { f = v.Field(k) } else { f = v.Index(k) } align := byte(f.Type().Align()*8 - 1) shift = (shift + align) &^ align if shift >= 64 { shift = 0 flushed = true if class == _FLOAT { addFloat(uintptr(val)) } else { addInt(uintptr(val)) } } switch f.Type().Kind() { case reflect.Struct: place(f) case reflect.Bool: if f.Bool() { val |= 1 << shift } shift += 8 class |= _INT case reflect.Uint8: val |= f.Uint() << shift shift += 8 class |= _INT case reflect.Uint16: val |= f.Uint() << shift shift += 16 class |= _INT case reflect.Uint32: val |= f.Uint() << shift shift += 32 class |= _INT case reflect.Uint64, reflect.Uint, reflect.Uintptr: addInt(uintptr(f.Uint())) shift = 0 flushed = true class = _NO_CLASS case reflect.Int8: val |= uint64(f.Int()&0xFF) << shift shift += 8 class |= _INT case reflect.Int16: val |= uint64(f.Int()&0xFFFF) << shift shift += 16 class |= _INT case reflect.Int32: val |= uint64(f.Int()&0xFFFF_FFFF) << shift shift += 32 class |= _INT case reflect.Int64, reflect.Int: addInt(uintptr(f.Int())) shift = 0 flushed = true class = _NO_CLASS case reflect.Float32: if class == _FLOAT { addFloat(uintptr(val)) val = 0 shift = 0 } val |= uint64(math.Float32bits(float32(f.Float()))) << shift shift += 32 class |= _FLOAT case reflect.Float64: addFloat(uintptr(math.Float64bits(float64(f.Float())))) shift = 0 flushed = true class = _NO_CLASS case reflect.Ptr: addInt(f.Pointer()) shift = 0 flushed = true class = _NO_CLASS case reflect.Array: place(f) default: panic("purego: unsupported kind " + f.Kind().String()) } } } place(v) if !flushed { if class == _FLOAT { addFloat(uintptr(val)) } else { addInt(uintptr(val)) } } } func placeStack(v reflect.Value, keepAlive []any, addInt func(uintptr)) []any { // Struct is too big to be placed in registers. // Copy to heap and place the pointer in register ptrStruct := reflect.New(v.Type()) ptrStruct.Elem().Set(v) ptr := ptrStruct.Elem().Addr().UnsafePointer() keepAlive = append(keepAlive, ptr) addInt(uintptr(ptr)) return keepAlive } golang-github-ebitengine-purego-0.9.1/struct_other.go000066400000000000000000000011651512124053000227260ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors //go:build !amd64 && !arm64 && !loong64 package purego import "reflect" func addStruct(v reflect.Value, numInts, numFloats, numStack *int, addInt, addFloat, addStack func(uintptr), keepAlive []any) []any { panic("purego: struct arguments are not supported") } func getStruct(outType reflect.Type, syscall syscall15Args) (v reflect.Value) { panic("purego: struct returns are not supported") } func placeRegisters(v reflect.Value, addFloat func(uintptr), addInt func(uintptr)) { panic("purego: not needed on other platforms") } golang-github-ebitengine-purego-0.9.1/struct_test.go000066400000000000000000000630661512124053000225740ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors //go:build darwin && (arm64 || amd64) package purego_test import ( "math" "os" "path/filepath" "runtime" "testing" "unsafe" "github.com/ebitengine/purego" ) func TestRegisterFunc_structArgs(t *testing.T) { libFileName := filepath.Join(t.TempDir(), "structtest.so") t.Logf("Build %v", libFileName) if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "structtest", "struct_test.c")); err != nil { t.Fatal(err) } defer os.Remove(libFileName) lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL) if err != nil { t.Fatalf("Dlopen(%q) failed: %v", libFileName, err) } const ( expectedUnsigned = 0xdeadbeef expectedSigned = -123 expectedOdd = 12 + 23 + 46 expectedLong uint64 = 0xdeadbeefcafebabe expectedFloat float32 = 10 expectedDouble float64 = 10 ) { type Empty struct{} var NoStruct func(Empty) int64 purego.RegisterLibFunc(&NoStruct, lib, "NoStruct") if ret := NoStruct(Empty{}); ret != expectedUnsigned { t.Fatalf("NoStruct returned %#x wanted %#x", ret, expectedUnsigned) } } { type EmptyEmpty struct{} var EmptyEmptyFn func(EmptyEmpty) int64 purego.RegisterLibFunc(&EmptyEmptyFn, lib, "EmptyEmpty") if ret := EmptyEmptyFn(EmptyEmpty{}); ret != expectedUnsigned { t.Fatalf("EmptyEmpty returned %#x wanted %#x", ret, expectedUnsigned) } var EmptyEmptyWithReg func(uint32, EmptyEmpty, uint32) int64 purego.RegisterLibFunc(&EmptyEmptyWithReg, lib, "EmptyEmptyWithReg") if ret := EmptyEmptyWithReg(0xdead, EmptyEmpty{}, 0xbeef); ret != expectedUnsigned { t.Fatalf("EmptyEmptyWithReg returned %#x wanted %#x", ret, expectedUnsigned) } } { type GreaterThan16Bytes struct { x, y, z *int64 } var x, y, z int64 = 0xEF, 0xBE00, 0xDEAD0000 var GreaterThan16BytesFn func(GreaterThan16Bytes) int64 purego.RegisterLibFunc(&GreaterThan16BytesFn, lib, "GreaterThan16Bytes") if ret := GreaterThan16BytesFn(GreaterThan16Bytes{x: &x, y: &y, z: &z}); ret != expectedUnsigned { t.Fatalf("GreaterThan16Bytes returned %#x wanted %#x", ret, expectedUnsigned) } } { type GreaterThan16BytesStruct struct { a struct { x, y, z *int64 } } var x, y, z int64 = 0xEF, 0xBE00, 0xDEAD0000 var GreaterThan16BytesStructFn func(GreaterThan16BytesStruct) int64 purego.RegisterLibFunc(&GreaterThan16BytesStructFn, lib, "GreaterThan16BytesStruct") if ret := GreaterThan16BytesStructFn(GreaterThan16BytesStruct{a: struct{ x, y, z *int64 }{x: &x, y: &y, z: &z}}); ret != expectedUnsigned { t.Fatalf("GreaterThan16BytesStructFn returned %#x wanted %#x", ret, expectedUnsigned) } } { type GreaterThan16Bytes struct { x, y, z *int64 } var x, y, z int64 = 0xEF, 0xBE00, 0xDEAD0000 var AfterRegisters func(a, b, c, d, e, f, g, h int, bytes GreaterThan16Bytes) int64 purego.RegisterLibFunc(&AfterRegisters, lib, "AfterRegisters") if ret := AfterRegisters(0xD0000000, 0xE000000, 0xA00000, 0xD0000, 0xB000, 0xE00, 0xE0, 0xF, GreaterThan16Bytes{x: &x, y: &y, z: &z}); ret != expectedUnsigned { t.Fatalf("AfterRegisters returned %#x wanted %#x", ret, expectedUnsigned) } var BeforeRegisters func(bytes GreaterThan16Bytes, a, b int64) uint64 z -= 0xFF purego.RegisterLibFunc(&BeforeRegisters, lib, "BeforeRegisters") if ret := BeforeRegisters(GreaterThan16Bytes{&x, &y, &z}, 0x0F, 0xF0); ret != expectedUnsigned { t.Fatalf("BeforeRegisters returned %#x wanted %#x", ret, expectedUnsigned) } } { type IntLessThan16Bytes struct { x, y int64 } var IntLessThan16BytesFn func(bytes IntLessThan16Bytes) int64 purego.RegisterLibFunc(&IntLessThan16BytesFn, lib, "IntLessThan16Bytes") if ret := IntLessThan16BytesFn(IntLessThan16Bytes{0xDEAD0000, 0xBEEF}); ret != expectedUnsigned { t.Fatalf("IntLessThan16BytesFn returned %#x wanted %#x", ret, expectedUnsigned) } } { type FloatLessThan16Bytes struct { x, y float32 } var FloatLessThan16BytesFn func(FloatLessThan16Bytes) float32 purego.RegisterLibFunc(&FloatLessThan16BytesFn, lib, "FloatLessThan16Bytes") if ret := FloatLessThan16BytesFn(FloatLessThan16Bytes{3, 7}); ret != expectedFloat { t.Fatalf("FloatLessThan16Bytes returned %f wanted %f", ret, expectedFloat) } } { type ThreeSmallFields struct { x, y, z float32 } var ThreeSmallFieldsFn func(ThreeSmallFields) float32 purego.RegisterLibFunc(&ThreeSmallFieldsFn, lib, "ThreeSmallFields") if ret := ThreeSmallFieldsFn(ThreeSmallFields{1, 2, 7}); ret != expectedFloat { t.Fatalf("ThreeSmallFields returned %f wanted %f", ret, expectedFloat) } } { type FloatAndInt struct { x float32 y int32 } var FloatAndIntFn func(FloatAndInt) float32 purego.RegisterLibFunc(&FloatAndIntFn, lib, "FloatAndInt") if ret := FloatAndIntFn(FloatAndInt{3, 7}); ret != expectedFloat { t.Fatalf("FloatAndIntFn returned %f wanted %f", ret, expectedFloat) } } { type DoubleStruct struct { x float64 } var DoubleStructFn func(DoubleStruct) float64 purego.RegisterLibFunc(&DoubleStructFn, lib, "DoubleStruct") if ret := DoubleStructFn(DoubleStruct{10}); ret != expectedDouble { t.Fatalf("DoubleStruct returned %f wanted %f", ret, expectedDouble) } } { type TwoDoubleStruct struct { x, y float64 } var TwoDoubleStructFn func(TwoDoubleStruct) float64 purego.RegisterLibFunc(&TwoDoubleStructFn, lib, "TwoDoubleStruct") if ret := TwoDoubleStructFn(TwoDoubleStruct{3, 7}); ret != expectedDouble { t.Fatalf("TwoDoubleStruct returned %f wanted %f", ret, expectedDouble) } } { type TwoDoubleTwoStruct struct { x struct { x, y float64 } } var TwoDoubleTwoStructFn func(TwoDoubleTwoStruct) float64 purego.RegisterLibFunc(&TwoDoubleTwoStructFn, lib, "TwoDoubleTwoStruct") if ret := TwoDoubleTwoStructFn(TwoDoubleTwoStruct{x: struct{ x, y float64 }{x: 3, y: 7}}); ret != expectedDouble { t.Fatalf("TwoDoubleTwoStruct returned %f wanted %f", ret, expectedDouble) } } { type ThreeDoubleStruct struct { x, y, z float64 } var ThreeDoubleStructFn func(ThreeDoubleStruct) float64 purego.RegisterLibFunc(&ThreeDoubleStructFn, lib, "ThreeDoubleStruct") if ret := ThreeDoubleStructFn(ThreeDoubleStruct{1, 3, 6}); ret != expectedDouble { t.Fatalf("ThreeDoubleStructFn returned %f wanted %f", ret, expectedDouble) } } { type LargeFloatStruct struct { a, b, c, d, e, f float64 } var LargeFloatStructFn func(LargeFloatStruct) float64 purego.RegisterLibFunc(&LargeFloatStructFn, lib, "LargeFloatStruct") if ret := LargeFloatStructFn(LargeFloatStruct{1, 2, 3, 4, 5, -5}); ret != expectedDouble { t.Fatalf("LargeFloatStructFn returned %f wanted %f", ret, expectedFloat) } var LargeFloatStructWithRegs func(a, b, c float64, s LargeFloatStruct) float64 purego.RegisterLibFunc(&LargeFloatStructWithRegs, lib, "LargeFloatStructWithRegs") if ret := LargeFloatStructWithRegs(1, -1, 0, LargeFloatStruct{1, 2, 3, 4, 5, -5}); ret != expectedDouble { t.Fatalf("LargeFloatStructWithRegs returned %f wanted %f", ret, expectedFloat) } } { type Rect struct { x, y, w, h float64 } var RectangleWithRegs func(a, b, c, d, e float64, rect Rect) float64 purego.RegisterLibFunc(&RectangleWithRegs, lib, "RectangleWithRegs") if ret := RectangleWithRegs(1, 2, 3, 4, -2, Rect{1, 2, 3, -4}); ret != expectedDouble { t.Fatalf("RectangleWithRegs returned %f wanted %f", ret, expectedDouble) } var RectangleSubtract func(rect Rect) float64 purego.RegisterLibFunc(&RectangleSubtract, lib, "RectangleSubtract") if ret := RectangleSubtract(Rect{15, 5, 3, 7}); ret != expectedDouble { t.Fatalf("RectangleSubtract returned %f wanted %f", ret, expectedDouble) } var Rectangle func(rect Rect) float64 purego.RegisterLibFunc(&Rectangle, lib, "Rectangle") if ret := Rectangle(Rect{1, 2, 3, 4}); ret != expectedDouble { t.Fatalf("Rectangle returned %f wanted %f", ret, expectedFloat) } } { type FloatArray struct { a [2]float64 } var FloatArrayFn func(rect FloatArray) float64 purego.RegisterLibFunc(&FloatArrayFn, lib, "FloatArray") if ret := FloatArrayFn(FloatArray{a: [2]float64{3, 7}}); ret != expectedDouble { t.Fatalf("FloatArray returned %f wanted %f", ret, expectedFloat) } } { type UnsignedChar4Bytes struct { a, b, c, d byte } var UnsignedChar4BytesFn func(UnsignedChar4Bytes) uint32 purego.RegisterLibFunc(&UnsignedChar4BytesFn, lib, "UnsignedChar4Bytes") if ret := UnsignedChar4BytesFn(UnsignedChar4Bytes{a: 0xDE, b: 0xAD, c: 0xBE, d: 0xEF}); ret != expectedUnsigned { t.Fatalf("UnsignedChar4BytesFn returned %#x wanted %#x", ret, expectedUnsigned) } } { type UnsignedChar4BytesStruct struct { x struct { a byte } y struct { b byte } z struct { c byte } w struct { d byte } } var UnsignedChar4BytesStructFn func(UnsignedChar4BytesStruct) uint32 purego.RegisterLibFunc(&UnsignedChar4BytesStructFn, lib, "UnsignedChar4BytesStruct") if ret := UnsignedChar4BytesStructFn(UnsignedChar4BytesStruct{ x: struct{ a byte }{a: 0xDE}, y: struct{ b byte }{b: 0xAD}, z: struct{ c byte }{c: 0xBE}, w: struct{ d byte }{d: 0xEF}, }); ret != expectedUnsigned { t.Fatalf("UnsignedChar4BytesStructFn returned %#x wanted %#x", ret, expectedUnsigned) } } { type Short struct { a, b, c, d uint16 } var ShortFn func(Short) uint64 purego.RegisterLibFunc(&ShortFn, lib, "Short") if ret := ShortFn(Short{a: 0xDEAD, b: 0xBEEF, c: 0xCAFE, d: 0xBABE}); ret != expectedLong { t.Fatalf("ShortFn returned %#x wanted %#x", ret, expectedLong) } } { type Int struct { a, b uint32 } var IntFn func(Int) uint64 purego.RegisterLibFunc(&IntFn, lib, "Int") if ret := IntFn(Int{a: 0xDEADBEEF, b: 0xCAFEBABE}); ret != expectedLong { t.Fatalf("IntFn returned %#x wanted %#x", ret, expectedLong) } } { type Long struct { a uint64 } var LongFn func(Long) uint64 purego.RegisterLibFunc(&LongFn, lib, "Long") if ret := LongFn(Long{a: 0xDEADBEEFCAFEBABE}); ret != expectedLong { t.Fatalf("LongFn returned %#x wanted %#x", ret, expectedLong) } } { type Char8Bytes struct { a, b, c, d, e, f, g, h int8 } var Char8BytesFn func(Char8Bytes) int32 purego.RegisterLibFunc(&Char8BytesFn, lib, "Char8Bytes") if ret := Char8BytesFn(Char8Bytes{a: -128, b: 127, c: 3, d: -88, e: -3, f: 34, g: -48, h: -20}); ret != expectedSigned { t.Fatalf("Char8Bytes returned %d wanted %d", ret, expectedSigned) } } { type Odd struct { a, b, c byte } var OddFn func(Odd) int32 purego.RegisterLibFunc(&OddFn, lib, "Odd") if ret := OddFn(Odd{a: 12, b: 23, c: 46}); ret != expectedOdd { t.Fatalf("OddFn returned %d wanted %d", ret, expectedOdd) } } { type Char2Short1 struct { a, b byte c uint16 } var Char2Short1s func(Char2Short1) int32 purego.RegisterLibFunc(&Char2Short1s, lib, "Char2Short1s") if ret := Char2Short1s(Char2Short1{a: 12, b: 23, c: 46}); ret != expectedOdd { t.Fatalf("Char2Short1s returned %d wanted %d", ret, expectedOdd) } } { type SignedChar2Short1 struct { a, b int8 c int16 } var SignedChar2Short1Fn func(SignedChar2Short1) int32 purego.RegisterLibFunc(&SignedChar2Short1Fn, lib, "SignedChar2Short1") if ret := SignedChar2Short1Fn(SignedChar2Short1{a: 100, b: -23, c: -200}); ret != expectedSigned { t.Fatalf("SignedChar2Short1Fn returned %d wanted %d", ret, expectedSigned) } } { type Array4UnsignedChars struct { a [4]uint8 } var Array4UnsignedCharsFn func(chars Array4UnsignedChars) uint32 purego.RegisterLibFunc(&Array4UnsignedCharsFn, lib, "Array4UnsignedChars") if ret := Array4UnsignedCharsFn(Array4UnsignedChars{a: [...]uint8{0xDE, 0xAD, 0xBE, 0xEF}}); ret != expectedUnsigned { t.Fatalf("Array4UnsignedCharsFn returned %#x wanted %#x", ret, expectedUnsigned) } } { type Array3UnsignedChar struct { a [3]uint8 } var Array3UnsignedChars func(chars Array3UnsignedChar) uint32 purego.RegisterLibFunc(&Array3UnsignedChars, lib, "Array3UnsignedChars") if ret := Array3UnsignedChars(Array3UnsignedChar{a: [...]uint8{0xDE, 0xAD, 0xBE}}); ret != expectedUnsigned { t.Fatalf("Array4UnsignedCharsFn returned %#x wanted %#x", ret, expectedUnsigned) } } { type Array2UnsignedShort struct { a [2]uint16 } var Array2UnsignedShorts func(chars Array2UnsignedShort) uint32 purego.RegisterLibFunc(&Array2UnsignedShorts, lib, "Array2UnsignedShorts") if ret := Array2UnsignedShorts(Array2UnsignedShort{a: [...]uint16{0xDEAD, 0xBEEF}}); ret != expectedUnsigned { t.Fatalf("Array4UnsignedCharsFn returned %#x wanted %#x", ret, expectedUnsigned) } } { type Array4Chars struct { a [4]int8 } var Array4CharsFn func(chars Array4Chars) int32 purego.RegisterLibFunc(&Array4CharsFn, lib, "Array4Chars") const expectedSum = 1 + 2 + 4 + 8 if ret := Array4CharsFn(Array4Chars{a: [...]int8{1, 2, 4, 8}}); ret != expectedSum { t.Fatalf("Array4CharsFn returned %d wanted %d", ret, expectedSum) } } { type Array2Short struct { a [2]int16 } var Array2Shorts func(chars Array2Short) int32 purego.RegisterLibFunc(&Array2Shorts, lib, "Array2Shorts") if ret := Array2Shorts(Array2Short{a: [...]int16{-333, 210}}); ret != expectedSigned { t.Fatalf("Array4Shorts returned %#x wanted %#x", ret, expectedSigned) } } { type Array3Short struct { a [3]int16 } var Array3Shorts func(chars Array3Short) int32 purego.RegisterLibFunc(&Array3Shorts, lib, "Array3Shorts") if ret := Array3Shorts(Array3Short{a: [...]int16{-333, 100, 110}}); ret != expectedSigned { t.Fatalf("Array4Shorts returned %#x wanted %#x", ret, expectedSigned) } } { type BoolStruct struct { b bool } var BoolStructFn func(BoolStruct) bool purego.RegisterLibFunc(&BoolStructFn, lib, "BoolStruct") if ret := BoolStructFn(BoolStruct{true}); ret != true { t.Fatalf("BoolStructFn returned %v wanted %v", ret, true) } if ret := BoolStructFn(BoolStruct{false}); ret != false { t.Fatalf("BoolStructFn returned %v wanted %v", ret, false) } } { type BoolFloat struct { b bool _ [3]byte // purego won't do padding for you so make sure it aligns properly with C struct f float32 } var BoolFloatFn func(BoolFloat) float32 purego.RegisterLibFunc(&BoolFloatFn, lib, "BoolFloat") if ret := BoolFloatFn(BoolFloat{b: true, f: 10}); ret != expectedFloat { t.Fatalf("BoolFloatFn returned %f wanted %f", ret, expectedFloat) } if ret := BoolFloatFn(BoolFloat{b: false, f: 10}); ret != -expectedFloat { t.Fatalf("BoolFloatFn returned %f wanted %f", ret, -expectedFloat) } } { type point struct{ x, y float64 } type size struct{ width, height float64 } type Content struct { point point size size } var InitWithContentRect func(*int, Content, int32, int32, bool) uint64 purego.RegisterLibFunc(&InitWithContentRect, lib, "InitWithContentRect") if ret := InitWithContentRect(new(int), // These numbers are created so that when added together and then divided by 11 it produces 0xdeadbeef Content{point{x: 41_000_000_000, y: 95_000_000}, size{width: 214_000, height: 149}}, 15, 4, true); ret != expectedUnsigned { t.Fatalf("InitWithContentRect returned %d wanted %#x", ret, expectedUnsigned) } } { type GoInt4 struct { A, B, C, D int } var GoInt4Fn func(GoInt4) int purego.RegisterLibFunc(&GoInt4Fn, lib, "GoInt4") const expected = math.MaxInt - 52 - 3 + 4 if ret := GoInt4Fn(GoInt4{math.MaxInt, -52, 3, 4}); ret != expected { t.Fatalf("GoInt4Fn returned %d wanted %#x", ret, expected) } } { type GoUint4 struct { A, B, C, D uint } var GoUint4Fn func(GoUint4) uint purego.RegisterLibFunc(&GoUint4Fn, lib, "GoUint4") const expected = 1_000_000 + 53 + 71 + 8 if ret := GoUint4Fn(GoUint4{1_000_000, 53, 71, 8}); ret != expected { t.Fatalf("GoUint4Fn returned %d wanted %#x", ret, expected) } } { type OneLong struct{ a uintptr } var TakeGoUintAndReturn func(a OneLong) uint64 purego.RegisterLibFunc(&TakeGoUintAndReturn, lib, "TakeGoUintAndReturn") expected := uint64(7) if ret := TakeGoUintAndReturn(OneLong{7}); ret != expected { t.Fatalf("TakeGoUintAndReturn returned %+v wanted %+v", ret, expected) } } { type FloatAndBool struct { x float32 y bool } var FloatAndBoolFn func(FloatAndBool) int32 purego.RegisterLibFunc(&FloatAndBoolFn, lib, "FloatAndBool") if ret := FloatAndBoolFn(FloatAndBool{x: 12345.0, y: true}); ret != 1 { t.Fatalf("FloatAndBool(y: true) = %d, want 1", ret) } if ret := FloatAndBoolFn(FloatAndBool{x: 12345.0, y: false}); ret != 0 { t.Fatalf("FloatAndBool(y: false) = %d, want 0", ret) } } { type FourInt32s struct { f0, f1, f2, f3 int32 } var FourInt32sFn func(FourInt32s) int32 purego.RegisterLibFunc(&FourInt32sFn, lib, "FourInt32s") result := FourInt32sFn(FourInt32s{100, -127, 4, -100}) const want = 100 - 127 + 4 - 100 if result != want { t.Fatalf("FourInt32s returned %d wanted %d", result, want) } } } func TestRegisterFunc_structReturns(t *testing.T) { libFileName := filepath.Join(t.TempDir(), "structreturntest.so") t.Logf("Build %v", libFileName) if err := buildSharedLib("CC", libFileName, filepath.Join("testdata", "structtest", "structreturn_test.c")); err != nil { t.Fatal(err) } defer os.Remove(libFileName) lib, err := purego.Dlopen(libFileName, purego.RTLD_NOW|purego.RTLD_GLOBAL) if err != nil { t.Fatalf("Dlopen(%q) failed: %v", libFileName, err) } { type Empty struct{} var ReturnEmpty func() Empty purego.RegisterLibFunc(&ReturnEmpty, lib, "ReturnEmpty") ret := ReturnEmpty() _ = ret } { type inner struct{ a int16 } type StructInStruct struct { a inner b inner c inner } var ReturnStructInStruct func(a, b, c int16) StructInStruct purego.RegisterLibFunc(&ReturnStructInStruct, lib, "ReturnStructInStruct") expected := StructInStruct{inner{^int16(0)}, inner{2}, inner{3}} if ret := ReturnStructInStruct(^int16(0), 2, 3); ret != expected { t.Fatalf("StructInStruct returned %+v wanted %+v", ret, expected) } } { type ThreeShorts struct{ a, b, c int16 } var ReturnThreeShorts func(a, b, c int16) ThreeShorts purego.RegisterLibFunc(&ReturnThreeShorts, lib, "ReturnThreeShorts") expected := ThreeShorts{^int16(0), 2, 3} if ret := ReturnThreeShorts(^int16(0), 2, 3); ret != expected { t.Fatalf("ReturnThreeShorts returned %+v wanted %+v", ret, expected) } } { type FourShorts struct{ a, b, c, d int16 } var ReturnFourShorts func(a, b, c, d int16) FourShorts purego.RegisterLibFunc(&ReturnFourShorts, lib, "ReturnFourShorts") expected := FourShorts{^int16(0), 2, 3, 4} if ret := ReturnFourShorts(^int16(0), 2, 3, 4); ret != expected { t.Fatalf("ReturnFourShorts returned %+v wanted %+v", ret, expected) } } { type OneLong struct{ a int64 } var ReturnOneLong func(a int64) OneLong purego.RegisterLibFunc(&ReturnOneLong, lib, "ReturnOneLong") expected := OneLong{5} if ret := ReturnOneLong(5); ret != expected { t.Fatalf("ReturnOneLong returned %+v wanted %+v", ret, expected) } } { type TwoLongs struct{ a, b int64 } var ReturnTwoLongs func(a, b int64) TwoLongs purego.RegisterLibFunc(&ReturnTwoLongs, lib, "ReturnTwoLongs") expected := TwoLongs{1, 2} if ret := ReturnTwoLongs(1, 2); ret != expected { t.Fatalf("ReturnTwoLongs returned %+v wanted %+v", ret, expected) } } { type ThreeLongs struct{ a, b, c int64 } var ReturnThreeLongs func(a, b, c int64) ThreeLongs purego.RegisterLibFunc(&ReturnThreeLongs, lib, "ReturnThreeLongs") expected := ThreeLongs{1, 2, 3} if ret := ReturnThreeLongs(1, 2, 3); ret != expected { t.Fatalf("ReturnThreeLongs returned %+v wanted %+v", ret, expected) } } { type OneFloat struct{ a float32 } var ReturnOneFloat func(a float32) OneFloat purego.RegisterLibFunc(&ReturnOneFloat, lib, "ReturnOneFloat") expected := OneFloat{1} if ret := ReturnOneFloat(1); ret != expected { t.Fatalf("ReturnOneFloat returned %+v wanted %+v", ret, expected) } } { type TwoFloats struct{ a, b float32 } var ReturnTwoFloats func(a, b float32) TwoFloats purego.RegisterLibFunc(&ReturnTwoFloats, lib, "ReturnTwoFloats") expected := TwoFloats{3, 10} if ret := ReturnTwoFloats(5, 2); ret != expected { t.Fatalf("ReturnTwoFloats returned %+v wanted %+v", ret, expected) } } { type ThreeFloats struct{ a, b, c float32 } var ReturnThreeFloats func(a, b, c float32) ThreeFloats purego.RegisterLibFunc(&ReturnThreeFloats, lib, "ReturnThreeFloats") expected := ThreeFloats{1, 2, 3} if ret := ReturnThreeFloats(1, 2, 3); ret != expected { t.Fatalf("ReturnThreeFloats returned %+v wanted %+v", ret, expected) } } { type OneDouble struct{ a float64 } var ReturnOneDouble func(a float64) OneDouble purego.RegisterLibFunc(&ReturnOneDouble, lib, "ReturnOneDouble") expected := OneDouble{1} if ret := ReturnOneDouble(1); ret != expected { t.Fatalf("ReturnOneDouble returned %+v wanted %+v", ret, expected) } } { type TwoDoubles struct{ a, b float64 } var ReturnTwoDoubles func(a, b float64) TwoDoubles purego.RegisterLibFunc(&ReturnTwoDoubles, lib, "ReturnTwoDoubles") expected := TwoDoubles{1, 2} if ret := ReturnTwoDoubles(1, 2); ret != expected { t.Fatalf("ReturnTwoDoubles returned %+v wanted %+v", ret, expected) } } { type ThreeDoubles struct{ a, b, c float64 } var ReturnThreeDoubles func(a, b, c float64) ThreeDoubles purego.RegisterLibFunc(&ReturnThreeDoubles, lib, "ReturnThreeDoubles") expected := ThreeDoubles{1, 2, 3} if ret := ReturnThreeDoubles(1, 2, 3); ret != expected { t.Fatalf("ReturnThreeDoubles returned %+v wanted %+v", ret, expected) } } { type FourDoubles struct{ a, b, c, d float64 } var ReturnFourDoubles func(a, b, c, d float64) FourDoubles purego.RegisterLibFunc(&ReturnFourDoubles, lib, "ReturnFourDoubles") expected := FourDoubles{1, 2, 3, 4} if ret := ReturnFourDoubles(1, 2, 3, 4); ret != expected { t.Fatalf("ReturnFourDoubles returned %+v wanted %+v", ret, expected) } } { type FourDoublesInternal struct { f struct{ a, b float64 } g struct{ c, d float64 } } var ReturnFourDoublesInternal func(a, b, c, d float64) FourDoublesInternal purego.RegisterLibFunc(&ReturnFourDoublesInternal, lib, "ReturnFourDoublesInternal") expected := FourDoublesInternal{f: struct{ a, b float64 }{a: 1, b: 2}, g: struct{ c, d float64 }{c: 3, d: 4}} if ret := ReturnFourDoublesInternal(1, 2, 3, 4); ret != expected { t.Fatalf("ReturnFourDoublesInternal returned %+v wanted %+v", ret, expected) } } { type FiveDoubles struct{ a, b, c, d, e float64 } var ReturnFiveDoubles func(a, b, c, d, e float64) FiveDoubles purego.RegisterLibFunc(&ReturnFiveDoubles, lib, "ReturnFiveDoubles") expected := FiveDoubles{1, 2, 3, 4, 5} if ret := ReturnFiveDoubles(1, 2, 3, 4, 5); ret != expected { t.Fatalf("ReturnFiveDoubles returned %+v wanted %+v", ret, expected) } } { type OneFloatOneDouble struct { a float32 _ float32 b float64 } var ReturnOneFloatOneDouble func(a float32, b float64) OneFloatOneDouble purego.RegisterLibFunc(&ReturnOneFloatOneDouble, lib, "ReturnOneFloatOneDouble") expected := OneFloatOneDouble{a: 1, b: 2} if ret := ReturnOneFloatOneDouble(1, 2); ret != expected { t.Fatalf("ReturnOneFloatOneDouble returned %+v wanted %+v", ret, expected) } } { type OneDoubleOneFloat struct { a float64 b float32 } var ReturnOneDoubleOneFloat func(a float64, b float32) OneDoubleOneFloat purego.RegisterLibFunc(&ReturnOneDoubleOneFloat, lib, "ReturnOneDoubleOneFloat") expected := OneDoubleOneFloat{1, 2} if ret := ReturnOneDoubleOneFloat(1, 2); ret != expected { t.Fatalf("ReturnOneDoubleOneFloat returned %+v wanted %+v", ret, expected) } } { type Unaligned1 struct { a int8 _ [1]int8 b int16 _ [1]int32 c int64 } var ReturnUnaligned1 func(a int8, b int16, c int64) Unaligned1 purego.RegisterLibFunc(&ReturnUnaligned1, lib, "ReturnUnaligned1") expected := Unaligned1{a: 1, b: 2, c: 3} if ret := ReturnUnaligned1(1, 2, 3); ret != expected { t.Fatalf("ReturnUnaligned1 returned %+v wanted %+v", ret, expected) } } { type Mixed1 struct { a float32 b int32 } var ReturnMixed1 func(a float32, b int32) Mixed1 purego.RegisterLibFunc(&ReturnMixed1, lib, "ReturnMixed1") expected := Mixed1{1, 2} if ret := ReturnMixed1(1, 2); ret != expected { t.Fatalf("ReturnMixed1 returned %+v wanted %+v", ret, expected) } } { type Mixed2 struct { a float32 b int32 c float32 d int32 } var ReturnMixed2 func(a float32, b int32, c float32, d int32) Mixed2 purego.RegisterLibFunc(&ReturnMixed2, lib, "ReturnMixed2") expected := Mixed2{1, 2, 3, 4} if ret := ReturnMixed2(1, 2, 3, 4); ret != expected { t.Fatalf("ReturnMixed2 returned %+v wanted %+v", ret, expected) } } { type Mixed3 struct { a float32 b uint32 c float64 } var ReturnMixed3 func(a float32, b uint32, c float64) Mixed3 purego.RegisterLibFunc(&ReturnMixed3, lib, "ReturnMixed3") expected := Mixed3{1, 2, 3} if ret := ReturnMixed3(1, 2, 3); ret != expected { t.Fatalf("ReturnMixed3 returned %+v wanted %+v", ret, expected) } } { type Mixed4 struct { a float64 b uint32 c float32 } var ReturnMixed4 func(a float64, b uint32, c float32) Mixed4 purego.RegisterLibFunc(&ReturnMixed4, lib, "ReturnMixed4") expected := Mixed4{1, 2, 3} if ret := ReturnMixed4(1, 2, 3); ret != expected { t.Fatalf("ReturnMixed4 returned %+v wanted %+v", ret, expected) } } { type Ptr1 struct { a *int64 b unsafe.Pointer } var ReturnPtr1 func(a *int64, b unsafe.Pointer) Ptr1 purego.RegisterLibFunc(&ReturnPtr1, lib, "ReturnPtr1") a, b := new(int64), new(struct{}) expected := Ptr1{a, unsafe.Pointer(b)} if ret := ReturnPtr1(a, unsafe.Pointer(b)); ret != expected { t.Fatalf("ReturnPtr1 returned %+v wanted %+v", ret, expected) } runtime.KeepAlive(a) runtime.KeepAlive(b) } } golang-github-ebitengine-purego-0.9.1/sys_amd64.s000066400000000000000000000117611512124053000216520ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build darwin || freebsd || linux || netbsd #include "textflag.h" #include "abi_amd64.h" #include "go_asm.h" #include "funcdata.h" #define STACK_SIZE 80 #define PTR_ADDRESS (STACK_SIZE - 8) // syscall15X calls a function in libc on behalf of the syscall package. // syscall15X takes a pointer to a struct like: // struct { // fn uintptr // a1 uintptr // a2 uintptr // a3 uintptr // a4 uintptr // a5 uintptr // a6 uintptr // a7 uintptr // a8 uintptr // a9 uintptr // a10 uintptr // a11 uintptr // a12 uintptr // a13 uintptr // a14 uintptr // a15 uintptr // r1 uintptr // r2 uintptr // err uintptr // } // syscall15X must be called on the g0 stack with the // C calling convention (use libcCall). GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8 DATA ·syscall15XABI0(SB)/8, $syscall15X(SB) TEXT syscall15X(SB), NOSPLIT|NOFRAME, $0 PUSHQ BP MOVQ SP, BP SUBQ $STACK_SIZE, SP MOVQ DI, PTR_ADDRESS(BP) // save the pointer MOVQ DI, R11 MOVQ syscall15Args_f1(R11), X0 // f1 MOVQ syscall15Args_f2(R11), X1 // f2 MOVQ syscall15Args_f3(R11), X2 // f3 MOVQ syscall15Args_f4(R11), X3 // f4 MOVQ syscall15Args_f5(R11), X4 // f5 MOVQ syscall15Args_f6(R11), X5 // f6 MOVQ syscall15Args_f7(R11), X6 // f7 MOVQ syscall15Args_f8(R11), X7 // f8 MOVQ syscall15Args_a1(R11), DI // a1 MOVQ syscall15Args_a2(R11), SI // a2 MOVQ syscall15Args_a3(R11), DX // a3 MOVQ syscall15Args_a4(R11), CX // a4 MOVQ syscall15Args_a5(R11), R8 // a5 MOVQ syscall15Args_a6(R11), R9 // a6 // push the remaining paramters onto the stack MOVQ syscall15Args_a7(R11), R12 MOVQ R12, 0(SP) // push a7 MOVQ syscall15Args_a8(R11), R12 MOVQ R12, 8(SP) // push a8 MOVQ syscall15Args_a9(R11), R12 MOVQ R12, 16(SP) // push a9 MOVQ syscall15Args_a10(R11), R12 MOVQ R12, 24(SP) // push a10 MOVQ syscall15Args_a11(R11), R12 MOVQ R12, 32(SP) // push a11 MOVQ syscall15Args_a12(R11), R12 MOVQ R12, 40(SP) // push a12 MOVQ syscall15Args_a13(R11), R12 MOVQ R12, 48(SP) // push a13 MOVQ syscall15Args_a14(R11), R12 MOVQ R12, 56(SP) // push a14 MOVQ syscall15Args_a15(R11), R12 MOVQ R12, 64(SP) // push a15 XORL AX, AX // vararg: say "no float args" MOVQ syscall15Args_fn(R11), R10 // fn CALL R10 MOVQ PTR_ADDRESS(BP), DI // get the pointer back MOVQ AX, syscall15Args_a1(DI) // r1 MOVQ DX, syscall15Args_a2(DI) // r3 MOVQ X0, syscall15Args_f1(DI) // f1 MOVQ X1, syscall15Args_f2(DI) // f2 XORL AX, AX // no error (it's ignored anyway) ADDQ $STACK_SIZE, SP MOVQ BP, SP POPQ BP RET TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 MOVQ 0(SP), AX // save the return address to calculate the cb index MOVQ 8(SP), R10 // get the return SP so that we can align register args with stack args ADDQ $8, SP // remove return address from stack, we are not returning to callbackasm, but to its caller. // make space for first six int and 8 float arguments below the frame ADJSP $14*8, SP MOVSD X0, (1*8)(SP) MOVSD X1, (2*8)(SP) MOVSD X2, (3*8)(SP) MOVSD X3, (4*8)(SP) MOVSD X4, (5*8)(SP) MOVSD X5, (6*8)(SP) MOVSD X6, (7*8)(SP) MOVSD X7, (8*8)(SP) MOVQ DI, (9*8)(SP) MOVQ SI, (10*8)(SP) MOVQ DX, (11*8)(SP) MOVQ CX, (12*8)(SP) MOVQ R8, (13*8)(SP) MOVQ R9, (14*8)(SP) LEAQ 8(SP), R8 // R8 = address of args vector PUSHQ R10 // push the stack pointer below registers // Switch from the host ABI to the Go ABI. PUSH_REGS_HOST_TO_ABI0() // determine index into runtime·cbs table MOVQ $callbackasm(SB), DX SUBQ DX, AX MOVQ $0, DX MOVQ $5, CX // divide by 5 because each call instruction in ·callbacks is 5 bytes long DIVL CX SUBQ $1, AX // subtract 1 because return PC is to the next slot // Create a struct callbackArgs on our stack to be passed as // the "frame" to cgocallback and on to callbackWrap. // $24 to make enough room for the arguments to runtime.cgocallback SUBQ $(24+callbackArgs__size), SP MOVQ AX, (24+callbackArgs_index)(SP) // callback index MOVQ R8, (24+callbackArgs_args)(SP) // address of args vector MOVQ $0, (24+callbackArgs_result)(SP) // result LEAQ 24(SP), AX // take the address of callbackArgs // Call cgocallback, which will call callbackWrap(frame). MOVQ ·callbackWrap_call(SB), DI // Get the ABIInternal function pointer MOVQ (DI), DI // without by using a closure. MOVQ AX, SI // frame (address of callbackArgs) MOVQ $0, CX // context CALL crosscall2(SB) // runtime.cgocallback(fn, frame, ctxt uintptr) // Get callback result. MOVQ (24+callbackArgs_result)(SP), AX ADDQ $(24+callbackArgs__size), SP // remove callbackArgs struct POP_REGS_HOST_TO_ABI0() POPQ R10 // get the SP back ADJSP $-14*8, SP // remove arguments MOVQ R10, 0(SP) RET golang-github-ebitengine-purego-0.9.1/sys_arm64.s000066400000000000000000000053141512124053000216650ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build darwin || freebsd || linux || netbsd || windows #include "textflag.h" #include "go_asm.h" #include "funcdata.h" #define STACK_SIZE 64 #define PTR_ADDRESS (STACK_SIZE - 8) // syscall15X calls a function in libc on behalf of the syscall package. // syscall15X takes a pointer to a struct like: // struct { // fn uintptr // a1 uintptr // a2 uintptr // a3 uintptr // a4 uintptr // a5 uintptr // a6 uintptr // a7 uintptr // a8 uintptr // a9 uintptr // a10 uintptr // a11 uintptr // a12 uintptr // a13 uintptr // a14 uintptr // a15 uintptr // r1 uintptr // r2 uintptr // err uintptr // } // syscall15X must be called on the g0 stack with the // C calling convention (use libcCall). GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8 DATA ·syscall15XABI0(SB)/8, $syscall15X(SB) TEXT syscall15X(SB), NOSPLIT, $0 SUB $STACK_SIZE, RSP // push structure pointer MOVD R0, PTR_ADDRESS(RSP) MOVD R0, R9 FMOVD syscall15Args_f1(R9), F0 // f1 FMOVD syscall15Args_f2(R9), F1 // f2 FMOVD syscall15Args_f3(R9), F2 // f3 FMOVD syscall15Args_f4(R9), F3 // f4 FMOVD syscall15Args_f5(R9), F4 // f5 FMOVD syscall15Args_f6(R9), F5 // f6 FMOVD syscall15Args_f7(R9), F6 // f7 FMOVD syscall15Args_f8(R9), F7 // f8 MOVD syscall15Args_a1(R9), R0 // a1 MOVD syscall15Args_a2(R9), R1 // a2 MOVD syscall15Args_a3(R9), R2 // a3 MOVD syscall15Args_a4(R9), R3 // a4 MOVD syscall15Args_a5(R9), R4 // a5 MOVD syscall15Args_a6(R9), R5 // a6 MOVD syscall15Args_a7(R9), R6 // a7 MOVD syscall15Args_a8(R9), R7 // a8 MOVD syscall15Args_arm64_r8(R9), R8 // r8 MOVD syscall15Args_a9(R9), R10 MOVD R10, 0(RSP) // push a9 onto stack MOVD syscall15Args_a10(R9), R10 MOVD R10, 8(RSP) // push a10 onto stack MOVD syscall15Args_a11(R9), R10 MOVD R10, 16(RSP) // push a11 onto stack MOVD syscall15Args_a12(R9), R10 MOVD R10, 24(RSP) // push a12 onto stack MOVD syscall15Args_a13(R9), R10 MOVD R10, 32(RSP) // push a13 onto stack MOVD syscall15Args_a14(R9), R10 MOVD R10, 40(RSP) // push a14 onto stack MOVD syscall15Args_a15(R9), R10 MOVD R10, 48(RSP) // push a15 onto stack MOVD syscall15Args_fn(R9), R10 // fn BL (R10) MOVD PTR_ADDRESS(RSP), R2 // pop structure pointer ADD $STACK_SIZE, RSP MOVD R0, syscall15Args_a1(R2) // save r1 MOVD R1, syscall15Args_a2(R2) // save r3 FMOVD F0, syscall15Args_f1(R2) // save f0 FMOVD F1, syscall15Args_f2(R2) // save f1 FMOVD F2, syscall15Args_f3(R2) // save f2 FMOVD F3, syscall15Args_f4(R2) // save f3 RET golang-github-ebitengine-purego-0.9.1/sys_loong64.s000066400000000000000000000044731512124053000222310ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors //go:build linux #include "textflag.h" #include "go_asm.h" #include "funcdata.h" #define STACK_SIZE 64 #define PTR_ADDRESS (STACK_SIZE - 8) // syscall15X calls a function in libc on behalf of the syscall package. // syscall15X takes a pointer to a struct like: // struct { // fn uintptr // a1 uintptr // a2 uintptr // a3 uintptr // a4 uintptr // a5 uintptr // a6 uintptr // a7 uintptr // a8 uintptr // a9 uintptr // a10 uintptr // a11 uintptr // a12 uintptr // a13 uintptr // a14 uintptr // a15 uintptr // r1 uintptr // r2 uintptr // err uintptr // } // syscall15X must be called on the g0 stack with the // C calling convention (use libcCall). GLOBL ·syscall15XABI0(SB), NOPTR|RODATA, $8 DATA ·syscall15XABI0(SB)/8, $syscall15X(SB) TEXT syscall15X(SB), NOSPLIT, $0 // push structure pointer SUBV $STACK_SIZE, R3 MOVV R4, PTR_ADDRESS(R3) MOVV R4, R13 MOVD syscall15Args_f1(R13), F0 // f1 MOVD syscall15Args_f2(R13), F1 // f2 MOVD syscall15Args_f3(R13), F2 // f3 MOVD syscall15Args_f4(R13), F3 // f4 MOVD syscall15Args_f5(R13), F4 // f5 MOVD syscall15Args_f6(R13), F5 // f6 MOVD syscall15Args_f7(R13), F6 // f7 MOVD syscall15Args_f8(R13), F7 // f8 MOVV syscall15Args_a1(R13), R4 // a1 MOVV syscall15Args_a2(R13), R5 // a2 MOVV syscall15Args_a3(R13), R6 // a3 MOVV syscall15Args_a4(R13), R7 // a4 MOVV syscall15Args_a5(R13), R8 // a5 MOVV syscall15Args_a6(R13), R9 // a6 MOVV syscall15Args_a7(R13), R10 // a7 MOVV syscall15Args_a8(R13), R11 // a8 // push a9-a15 onto stack MOVV syscall15Args_a9(R13), R12 MOVV R12, 0(R3) MOVV syscall15Args_a10(R13), R12 MOVV R12, 8(R3) MOVV syscall15Args_a11(R13), R12 MOVV R12, 16(R3) MOVV syscall15Args_a12(R13), R12 MOVV R12, 24(R3) MOVV syscall15Args_a13(R13), R12 MOVV R12, 32(R3) MOVV syscall15Args_a14(R13), R12 MOVV R12, 40(R3) MOVV syscall15Args_a15(R13), R12 MOVV R12, 48(R3) MOVV syscall15Args_fn(R13), R12 JAL (R12) // pop structure pointer MOVV PTR_ADDRESS(R3), R13 ADDV $STACK_SIZE, R3 // save R4, R5 MOVV R4, syscall15Args_a1(R13) MOVV R5, syscall15Args_a2(R13) // save f0-f3 MOVD F0, syscall15Args_f1(R13) MOVD F1, syscall15Args_f2(R13) MOVD F2, syscall15Args_f3(R13) MOVD F3, syscall15Args_f4(R13) RET golang-github-ebitengine-purego-0.9.1/sys_unix_arm64.s000066400000000000000000000041161512124053000227270ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors //go:build darwin || freebsd || linux || netbsd #include "textflag.h" #include "go_asm.h" #include "funcdata.h" #include "abi_arm64.h" TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 NO_LOCAL_POINTERS // On entry, the trampoline in zcallback_darwin_arm64.s left // the callback index in R12 (which is volatile in the C ABI). // Save callback register arguments R0-R7 and F0-F7. // We do this at the top of the frame so they're contiguous with stack arguments. SUB $(16*8), RSP, R14 FSTPD (F0, F1), (0*8)(R14) FSTPD (F2, F3), (2*8)(R14) FSTPD (F4, F5), (4*8)(R14) FSTPD (F6, F7), (6*8)(R14) STP (R0, R1), (8*8)(R14) STP (R2, R3), (10*8)(R14) STP (R4, R5), (12*8)(R14) STP (R6, R7), (14*8)(R14) // Adjust SP by frame size. SUB $(26*8), RSP // It is important to save R27 because the go assembler // uses it for move instructions for a variable. // This line: // MOVD ·callbackWrap_call(SB), R0 // Creates the instructions: // ADRP 14335(PC), R27 // MOVD 388(27), R0 // R27 is a callee saved register so we are responsible // for ensuring its value doesn't change. So save it and // restore it at the end of this function. // R30 is the link register. crosscall2 doesn't save it // so it's saved here. STP (R27, R30), 0(RSP) // Create a struct callbackArgs on our stack. MOVD $(callbackArgs__size)(RSP), R13 MOVD R12, callbackArgs_index(R13) // callback index MOVD R14, callbackArgs_args(R13) // address of args vector MOVD ZR, callbackArgs_result(R13) // result // Move parameters into registers // Get the ABIInternal function pointer // without by using a closure. MOVD ·callbackWrap_call(SB), R0 MOVD (R0), R0 // fn unsafe.Pointer MOVD R13, R1 // frame (&callbackArgs{...}) MOVD $0, R3 // ctxt uintptr BL crosscall2(SB) // Get callback result. MOVD $(callbackArgs__size)(RSP), R13 MOVD callbackArgs_result(R13), R0 // Restore LR and R27 LDP 0(RSP), (R27, R30) ADD $(26*8), RSP RET golang-github-ebitengine-purego-0.9.1/sys_unix_loong64.s000066400000000000000000000035121512124053000232650ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors //go:build linux #include "textflag.h" #include "go_asm.h" #include "funcdata.h" #include "abi_loong64.h" TEXT callbackasm1(SB), NOSPLIT|NOFRAME, $0 NO_LOCAL_POINTERS SUBV $(16*8), R3, R14 MOVD F0, 0(R14) MOVD F1, 8(R14) MOVD F2, 16(R14) MOVD F3, 24(R14) MOVD F4, 32(R14) MOVD F5, 40(R14) MOVD F6, 48(R14) MOVD F7, 56(R14) MOVV R4, 64(R14) MOVV R5, 72(R14) MOVV R6, 80(R14) MOVV R7, 88(R14) MOVV R8, 96(R14) MOVV R9, 104(R14) MOVV R10, 112(R14) MOVV R11, 120(R14) // Adjust SP by frame size. SUBV $(22*8), R3 // It is important to save R30 because the go assembler // uses it for move instructions for a variable. // This line: // MOVV ·callbackWrap_call(SB), R4 // Creates the instructions: // PCALAU12I off1(PC), R30 // MOVV off2(R30), R4 // R30 is a callee saved register so we are responsible // for ensuring its value doesn't change. So save it and // restore it at the end of this function. // R1 is the link register. crosscall2 doesn't save it // so it's saved here. MOVV R1, 0(R3) MOVV R30, 8(R3) // Create a struct callbackArgs on our stack. MOVV $(callbackArgs__size)(R3), R13 MOVV R12, callbackArgs_index(R13) // callback index MOVV R14, callbackArgs_args(R13) // address of args vector MOVV $0, callbackArgs_result(R13) // result // Move parameters into registers // Get the ABIInternal function pointer // without by using a closure. MOVV ·callbackWrap_call(SB), R4 MOVV (R4), R4 // fn unsafe.Pointer MOVV R13, R5 // frame (&callbackArgs{...}) MOVV $0, R7 // ctxt uintptr JAL crosscall2(SB) // Get callback result. MOVV $(callbackArgs__size)(R3), R13 MOVV callbackArgs_result(R13), R4 // Restore LR and R30 MOVV 0(R3), R1 MOVV 8(R3), R30 ADDV $(22*8), R3 RET golang-github-ebitengine-purego-0.9.1/syscall.go000066400000000000000000000044551512124053000216600ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build darwin || freebsd || linux || netbsd || windows package purego // CDecl marks a function as being called using the __cdecl calling convention as defined in // the [MSDocs] when passed to NewCallback. It must be the first argument to the function. // This is only useful on 386 Windows, but it is safe to use on other platforms. // // [MSDocs]: https://learn.microsoft.com/en-us/cpp/cpp/cdecl?view=msvc-170 type CDecl struct{} const ( maxArgs = 15 numOfFloatRegisters = 8 // arm64 and amd64 both have 8 float registers ) type syscall15Args struct { fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr f1, f2, f3, f4, f5, f6, f7, f8 uintptr arm64_r8 uintptr } // SyscallN takes fn, a C function pointer and a list of arguments as uintptr. // There is an internal maximum number of arguments that SyscallN can take. It panics // when the maximum is exceeded. It returns the result and the libc error code if there is one. // // In order to call this function properly make sure to follow all the rules specified in [unsafe.Pointer] // especially point 4. // // NOTE: SyscallN does not properly call functions that have both integer and float parameters. // See discussion comment https://github.com/ebiten/purego/pull/1#issuecomment-1128057607 // for an explanation of why that is. // // On amd64, if there are more than 8 floats the 9th and so on will be placed incorrectly on the // stack. // // The pragma go:nosplit is not needed at this function declaration because it uses go:uintptrescapes // which forces all the objects that the uintptrs point to onto the heap where a stack split won't affect // their memory location. // //go:uintptrescapes func SyscallN(fn uintptr, args ...uintptr) (r1, r2, err uintptr) { if fn == 0 { panic("purego: fn is nil") } if len(args) > maxArgs { panic("purego: too many arguments to SyscallN") } // add padding so there is no out-of-bounds slicing var tmp [maxArgs]uintptr copy(tmp[:], args) return syscall_syscall15X(fn, tmp[0], tmp[1], tmp[2], tmp[3], tmp[4], tmp[5], tmp[6], tmp[7], tmp[8], tmp[9], tmp[10], tmp[11], tmp[12], tmp[13], tmp[14]) } golang-github-ebitengine-purego-0.9.1/syscall_cgo_linux.go000066400000000000000000000011511512124053000237150ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build cgo && !(amd64 || arm64 || loong64) package purego import ( "github.com/ebitengine/purego/internal/cgo" ) var syscall15XABI0 = uintptr(cgo.Syscall15XABI0) //go:nosplit func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) { return cgo.Syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) } func NewCallback(_ any) uintptr { panic("purego: NewCallback on Linux is only supported on amd64/arm64/loong64") } golang-github-ebitengine-purego-0.9.1/syscall_sysv.go000066400000000000000000000155001512124053000227350ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors //go:build darwin || freebsd || (linux && (amd64 || arm64 || loong64)) || netbsd package purego import ( "reflect" "runtime" "sync" "unsafe" ) var syscall15XABI0 uintptr func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) { args := thePool.Get().(*syscall15Args) defer thePool.Put(args) *args = syscall15Args{ fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15, a1, a2, a3, a4, a5, a6, a7, a8, 0, } runtime_cgocall(syscall15XABI0, unsafe.Pointer(args)) return args.a1, args.a2, 0 } // NewCallback converts a Go function to a function pointer conforming to the C calling convention. // This is useful when interoperating with C code requiring callbacks. The argument is expected to be a // function with zero or one uintptr-sized result. The function must not have arguments with size larger than the size // of uintptr. Only a limited number of callbacks may be created in a single Go process, and any memory allocated // for these callbacks is never released. At least 2000 callbacks can always be created. Although this function // provides similar functionality to windows.NewCallback it is distinct. func NewCallback(fn any) uintptr { ty := reflect.TypeOf(fn) for i := 0; i < ty.NumIn(); i++ { in := ty.In(i) if !in.AssignableTo(reflect.TypeOf(CDecl{})) { continue } if i != 0 { panic("purego: CDecl must be the first argument") } } return compileCallback(fn) } // maxCb is the maximum number of callbacks // only increase this if you have added more to the callbackasm function const maxCB = 2000 var cbs struct { lock sync.Mutex numFn int // the number of functions currently in cbs.funcs funcs [maxCB]reflect.Value // the saved callbacks } type callbackArgs struct { index uintptr // args points to the argument block. // // The structure of the arguments goes // float registers followed by the // integer registers followed by the stack. // // This variable is treated as a continuous // block of memory containing all of the arguments // for this callback. args unsafe.Pointer // Below are out-args from callbackWrap result uintptr } func compileCallback(fn any) uintptr { val := reflect.ValueOf(fn) if val.Kind() != reflect.Func { panic("purego: the type must be a function but was not") } if val.IsNil() { panic("purego: function must not be nil") } ty := val.Type() for i := 0; i < ty.NumIn(); i++ { in := ty.In(i) switch in.Kind() { case reflect.Struct: if i == 0 && in.AssignableTo(reflect.TypeOf(CDecl{})) { continue } fallthrough case reflect.Interface, reflect.Func, reflect.Slice, reflect.Chan, reflect.Complex64, reflect.Complex128, reflect.String, reflect.Map, reflect.Invalid: panic("purego: unsupported argument type: " + in.Kind().String()) } } output: switch { case ty.NumOut() == 1: switch ty.Out(0).Kind() { case reflect.Pointer, reflect.Int, reflect.Int8, reflect.Int16, reflect.Int32, reflect.Int64, reflect.Uint, reflect.Uint8, reflect.Uint16, reflect.Uint32, reflect.Uint64, reflect.Uintptr, reflect.Bool, reflect.UnsafePointer: break output } panic("purego: unsupported return type: " + ty.String()) case ty.NumOut() > 1: panic("purego: callbacks can only have one return") } cbs.lock.Lock() defer cbs.lock.Unlock() if cbs.numFn >= maxCB { panic("purego: the maximum number of callbacks has been reached") } cbs.funcs[cbs.numFn] = val cbs.numFn++ return callbackasmAddr(cbs.numFn - 1) } const ptrSize = unsafe.Sizeof((*int)(nil)) const callbackMaxFrame = 64 * ptrSize // callbackasm is implemented in zcallback_GOOS_GOARCH.s // //go:linkname __callbackasm callbackasm var __callbackasm byte var callbackasmABI0 = uintptr(unsafe.Pointer(&__callbackasm)) // callbackWrap_call allows the calling of the ABIInternal wrapper // which is required for runtime.cgocallback without the // tag which is only allowed in the runtime. // This closure is used inside sys_darwin_GOARCH.s var callbackWrap_call = callbackWrap // callbackWrap is called by assembly code which determines which Go function to call. // This function takes the arguments and passes them to the Go function and returns the result. func callbackWrap(a *callbackArgs) { cbs.lock.Lock() fn := cbs.funcs[a.index] cbs.lock.Unlock() fnType := fn.Type() args := make([]reflect.Value, fnType.NumIn()) frame := (*[callbackMaxFrame]uintptr)(a.args) var floatsN int // floatsN represents the number of float arguments processed var intsN int // intsN represents the number of integer arguments processed // stack points to the index into frame of the current stack element. // The stack begins after the float and integer registers. stack := numOfIntegerRegisters() + numOfFloatRegisters for i := range args { var pos int switch fnType.In(i).Kind() { case reflect.Float32, reflect.Float64: if floatsN >= numOfFloatRegisters { pos = stack stack++ } else { pos = floatsN } floatsN++ case reflect.Struct: // This is the CDecl field args[i] = reflect.Zero(fnType.In(i)) continue default: if intsN >= numOfIntegerRegisters() { pos = stack stack++ } else { // the integers begin after the floats in frame pos = intsN + numOfFloatRegisters } intsN++ } args[i] = reflect.NewAt(fnType.In(i), unsafe.Pointer(&frame[pos])).Elem() } ret := fn.Call(args) if len(ret) > 0 { switch k := ret[0].Kind(); k { case reflect.Uint, reflect.Uint64, reflect.Uint32, reflect.Uint16, reflect.Uint8, reflect.Uintptr: a.result = uintptr(ret[0].Uint()) case reflect.Int, reflect.Int64, reflect.Int32, reflect.Int16, reflect.Int8: a.result = uintptr(ret[0].Int()) case reflect.Bool: if ret[0].Bool() { a.result = 1 } else { a.result = 0 } case reflect.Pointer: a.result = ret[0].Pointer() case reflect.UnsafePointer: a.result = ret[0].Pointer() default: panic("purego: unsupported kind: " + k.String()) } } } // callbackasmAddr returns address of runtime.callbackasm // function adjusted by i. // On x86 and amd64, runtime.callbackasm is a series of CALL instructions, // and we want callback to arrive at // correspondent call instruction instead of start of // runtime.callbackasm. // On ARM, runtime.callbackasm is a series of mov and branch instructions. // R12 is loaded with the callback index. Each entry is two instructions, // hence 8 bytes. func callbackasmAddr(i int) uintptr { var entrySize int switch runtime.GOARCH { default: panic("purego: unsupported architecture") case "386", "amd64": entrySize = 5 case "arm", "arm64", "loong64": // On ARM and ARM64, each entry is a MOV instruction // followed by a branch instruction entrySize = 8 } return callbackasmABI0 + uintptr(i*entrySize) } golang-github-ebitengine-purego-0.9.1/syscall_test.go000066400000000000000000000007351512124053000227140ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors package purego_test import ( "os" "testing" _ "github.com/ebitengine/purego" ) func TestOS(t *testing.T) { // set and unset an environment variable since this calls into fakecgo. err := os.Setenv("TESTING", "SOMETHING") if err != nil { t.Errorf("failed to Setenv: %s", err) } err = os.Unsetenv("TESTING") if err != nil { t.Errorf("failed to Unsetenv: %s", err) } } golang-github-ebitengine-purego-0.9.1/syscall_windows.go000066400000000000000000000031061512124053000234220ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2022 The Ebitengine Authors package purego import ( "reflect" "syscall" ) var syscall15XABI0 uintptr func syscall_syscall15X(fn, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15 uintptr) (r1, r2, err uintptr) { r1, r2, errno := syscall.Syscall15(fn, 15, a1, a2, a3, a4, a5, a6, a7, a8, a9, a10, a11, a12, a13, a14, a15) return r1, r2, uintptr(errno) } // NewCallback converts a Go function to a function pointer conforming to the stdcall calling convention. // This is useful when interoperating with Windows code requiring callbacks. The argument is expected to be a // function with one uintptr-sized result. The function must not have arguments with size larger than the // size of uintptr. Only a limited number of callbacks may be created in a single Go process, and any memory // allocated for these callbacks is never released. Between NewCallback and NewCallbackCDecl, at least 1024 // callbacks can always be created. Although this function is similiar to the darwin version it may act // differently. func NewCallback(fn any) uintptr { isCDecl := false ty := reflect.TypeOf(fn) for i := 0; i < ty.NumIn(); i++ { in := ty.In(i) if !in.AssignableTo(reflect.TypeOf(CDecl{})) { continue } if i != 0 { panic("purego: CDecl must be the first argument") } isCDecl = true } if isCDecl { return syscall.NewCallbackCDecl(fn) } return syscall.NewCallback(fn) } func loadSymbol(handle uintptr, name string) (uintptr, error) { return syscall.GetProcAddress(syscall.Handle(handle), name) } golang-github-ebitengine-purego-0.9.1/testdata/000077500000000000000000000000001512124053000214605ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/testdata/abitest/000077500000000000000000000000001512124053000231135ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/testdata/abitest/abi_test.c000066400000000000000000000022131512124053000250470ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2025 The Ebitengine Authors #include #include #include #include uint32_t stack_uint8_t(uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f, uint32_t g, uint32_t h, uint8_t i, uint8_t j, uint32_t k ) { assert(i == 1); assert(j == 2); assert(k == 1024); return a | b | c | d | e | f | g | h | (uint32_t) i | (uint32_t) j | k; } uint32_t reg_uint8_t(uint8_t a, uint8_t b, uint32_t c) { assert(a == 1); assert(b == 2); assert(c == 1024); return a | b | c; } uint32_t stack_string(uint32_t a, uint32_t b, uint32_t c, uint32_t d, uint32_t e, uint32_t f, uint32_t g, uint32_t h, const char * i) { assert(i != 0); assert(strcmp(i, "test") == 0); return a | b | c | d | e | f | g | h; } void stack_8i32_3strings(char* result, size_t size, int32_t a1, int32_t a2, int32_t a3, int32_t a4, int32_t a5, int32_t a6, int32_t a7, int32_t a8, const char* s1, const char* s2, const char* s3) { snprintf(result, size, "%d:%d:%d:%d:%d:%d:%d:%d:%s:%s:%s", a1, a2, a3, a4, a5, a6, a7, a8, s1, s2, s3); } golang-github-ebitengine-purego-0.9.1/testdata/libcbtest/000077500000000000000000000000001512124053000234335ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/testdata/libcbtest/callback_test.c000066400000000000000000000006101512124053000263670ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors #include typedef int (*callback)(const char *, int); int callCallback(const void *fp, const char *s) { // If the callback corrupts FP, this local variable on the stack will have incorrect value. int sentinel = 10101; ((callback)(fp))(s, strlen(s)); return sentinel; } golang-github-ebitengine-purego-0.9.1/testdata/libdlnested/000077500000000000000000000000001512124053000237515ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/testdata/libdlnested/nested_test.cpp000066400000000000000000000004561512124053000270030ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2023 The Ebitengine Authors #include struct nested_libdl { nested_libdl() { // Fails for sure because a symbol cannot be named like this dlsym(RTLD_DEFAULT, "@/*<>"); } }; static nested_libdl test; golang-github-ebitengine-purego-0.9.1/testdata/structtest/000077500000000000000000000000001512124053000237045ustar00rootroot00000000000000golang-github-ebitengine-purego-0.9.1/testdata/structtest/struct_test.c000066400000000000000000000164211512124053000264370ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors #include #include #include #if defined(__x86_64__) || defined(__aarch64__) typedef int64_t GoInt; typedef uint64_t GoUint; #endif // Empty is empty struct Empty {}; // NoStruct tests that an empty struct doesn't cause issues unsigned long NoStruct(struct Empty e) { return 0xdeadbeef; } struct EmptyEmpty { struct Empty x; }; unsigned long EmptyEmpty(struct EmptyEmpty e) { return 0xdeadbeef; } unsigned long EmptyEmptyWithReg(unsigned int x, struct EmptyEmpty e, unsigned int y) { return (x << 16) | y; } // GreaterThan16Bytes is 24 bytes on 64 bit systems struct GreaterThan16Bytes { long *x, *y, *z; }; // GreaterThan16Bytes is a basic test for structs bigger than 16 bytes unsigned long GreaterThan16Bytes(struct GreaterThan16Bytes g) { return *g.x + *g.y + *g.z; } // AfterRegisters tests to make sure that structs placed on the stack work properly unsigned long AfterRegisters(long a, long b, long c, long d, long e, long f, long g, long h, struct GreaterThan16Bytes bytes) { long registers = a + b + c + d + e + f + g + h; long stack = *bytes.x + *bytes.y + *bytes.z; if (registers != stack) { return 0xbadbad; } if (stack != 0xdeadbeef) { return 0xcafebad; } return stack; } unsigned long BeforeRegisters(struct GreaterThan16Bytes bytes, long a, long b) { return *bytes.x + *bytes.y + *bytes.z + a + b; } struct GreaterThan16BytesStruct { struct { long *x, *y, *z; } a ; }; unsigned long GreaterThan16BytesStruct(struct GreaterThan16BytesStruct g) { return *(g.a.x) + *(g.a.y) + *(g.a.z); } struct IntLessThan16Bytes { long x, y; }; unsigned long IntLessThan16Bytes(struct IntLessThan16Bytes l) { return l.x + l.y; } struct FloatLessThan16Bytes { float x, y; }; float FloatLessThan16Bytes(struct FloatLessThan16Bytes f) { return f.x + f.y; } struct ThreeSmallFields { float x, y, z; }; float ThreeSmallFields(struct ThreeSmallFields f) { return f.x + f.y + f.z; } struct FloatAndInt { float x; int y; }; float FloatAndInt(struct FloatAndInt f) { return f.x + f.y; } struct DoubleStruct { double x; }; double DoubleStruct(struct DoubleStruct d) { return d.x; } struct TwoDoubleStruct { double x, y; }; double TwoDoubleStruct(struct TwoDoubleStruct d) { return d.x + d.y; } struct TwoDoubleTwoStruct { struct { double x, y; } s; }; double TwoDoubleTwoStruct(struct TwoDoubleTwoStruct d) { return d.s.x + d.s.y; } struct ThreeDoubleStruct { double x, y, z; }; double ThreeDoubleStruct(struct ThreeDoubleStruct d) { return d.x + d.y + d.z; } struct LargeFloatStruct { double a, b, c, d, e, f; }; double LargeFloatStruct(struct LargeFloatStruct s) { return s.a + s.b + s.c + s.d + s.e + s.f; } double LargeFloatStructWithRegs(double a, double b, double c, struct LargeFloatStruct s) { return a + b + c + s.a + s.b + s.c + s.d + s.e + s.f; } struct Rect { double x, y, w, h; }; double Rectangle(struct Rect rect) { return rect.x + rect.y + rect.w + rect.h; } double RectangleSubtract(struct Rect rect) { return (rect.x + rect.y) - (rect.w + rect.h); } double RectangleWithRegs(double a, double b, double c, double d, double e, struct Rect rect) { return a + b + c + d + e + rect.x + rect.y + rect.w + rect.h; } struct FloatArray { double a[2]; }; double FloatArray(struct FloatArray f) { return f.a[0] + f.a[1]; } struct UnsignedChar4Bytes { unsigned char a, b, c, d; }; unsigned int UnsignedChar4Bytes(struct UnsignedChar4Bytes b) { return (((int)b.a)<<24) | (((int)b.b)<<16) | (((int)b.c)<<8) | (((int)b.d)<<0); } struct UnsignedChar4BytesStruct { struct { unsigned char a; } x; struct { unsigned char b; } y; struct { unsigned char c; } z; struct { unsigned char d; } w; }; unsigned int UnsignedChar4BytesStruct(struct UnsignedChar4BytesStruct b) { return (((int)b.x.a)<<24) | (((int)b.y.b)<<16) | (((int)b.z.c)<<8) | (((int)b.w.d)<<0); } struct Short { unsigned short a, b, c, d; }; unsigned long Short(struct Short s) { return (long)s.a << 48 | (long)s.b << 32 | (long)s.c << 16 | (long)s.d << 0; } struct Int { unsigned int a, b; }; unsigned long Int(struct Int i) { return (long)i.a << 32 | (long)i.b << 0; } struct Long { unsigned long a; }; unsigned long Long(struct Long l) { return l.a; } struct Char8Bytes { signed char a, b, c, d, e, f, g, h; }; int Char8Bytes(struct Char8Bytes b) { return (int)b.a + (int)b.b + (int)b.c + (int)b.d + (int)b.e + (int)b.f + (int)b.g + (int)b.h; } struct Odd { unsigned char a, b, c; }; int Odd(struct Odd o) { return (int)o.a + (int)o.b + (int)o.c; } struct Char2Short1 { unsigned char a, b; unsigned short c; }; int Char2Short1s(struct Char2Short1 s) { return (int)s.a + (int)s.b + (int)s.c; } struct SignedChar2Short1 { signed char a, b; signed short c; }; int SignedChar2Short1(struct SignedChar2Short1 s) { return s.a + s.b + s.c; } struct Array4UnsignedChars { unsigned char a[4]; }; unsigned int Array4UnsignedChars(struct Array4UnsignedChars a) { return (((int)a.a[0])<<24) | (((int)a.a[1])<<16) | (((int)a.a[2])<<8) | (((int)a.a[3])<<0); } struct Array3UnsignedChar { unsigned char a[3]; }; unsigned int Array3UnsignedChars(struct Array3UnsignedChar a) { return (((int)a.a[0])<<24) | (((int)a.a[1])<<16) | (((int)a.a[2])<<8) | 0xef; } struct Array2UnsignedShort { unsigned short a[2]; }; unsigned int Array2UnsignedShorts(struct Array2UnsignedShort a) { return (((int)a.a[0])<<16) | (((int)a.a[1])<<0); } struct Array4Chars { char a[4]; }; int Array4Chars(struct Array4Chars a) { return (int)a.a[0] + (int)a.a[1] + (int)a.a[2] + (int)a.a[3]; } struct Array2Short { short a[2]; }; int Array2Shorts(struct Array2Short a) { return (int)a.a[0] + (int)a.a[1]; } struct Array3Short { short a[3]; }; int Array3Shorts(struct Array3Short a) { return (int)a.a[0] + (int)a.a[1] + (int)a.a[2]; } struct BoolStruct { _Bool b; }; _Bool BoolStruct(struct BoolStruct b) { return b.b; } struct BoolFloat { _Bool b; float f; }; float BoolFloat(struct BoolFloat s) { if (s.b) return s.f; return -s.f; } struct Content { struct { double x, y; } point; struct { double width, height; } size; }; unsigned long InitWithContentRect(int *win, struct Content c, int style, int backing, _Bool flag) { if (win == 0) return 0xBAD; if (!flag) return 0xF1A6; // FLAG return (unsigned long)(c.point.x + c.point.y + c.size.width + c.size.height) / (style - backing); } struct GoInt4 { GoInt a, b, c, d; }; GoInt GoInt4(struct GoInt4 g) { return g.a + g.b - g.c + g.d; } struct GoUint4 { GoUint a, b, c, d; }; GoUint GoUint4(struct GoUint4 g) { return g.a + g.b + g.c + g.d; } GoUint TakeGoUintAndReturn(GoUint a) { return a; } struct FloatAndBool { float value; _Bool has_value; }; int FloatAndBool(struct FloatAndBool f) { return f.has_value; } struct FourInt32s { int32_t f0; int32_t f1; int32_t f2; int32_t f3; }; int32_t FourInt32s(struct FourInt32s s) { return s.f0 + s.f1 + s.f2 + s.f3; } golang-github-ebitengine-purego-0.9.1/testdata/structtest/structreturn_test.c000066400000000000000000000101361512124053000276740ustar00rootroot00000000000000// SPDX-License-Identifier: Apache-2.0 // SPDX-FileCopyrightText: 2024 The Ebitengine Authors #include struct Empty{}; struct Empty ReturnEmpty() { struct Empty e = {}; return e; } struct StructInStruct{ struct{ int16_t a; } a; struct{ int16_t b; } b; struct{ int16_t c; } c; }; struct StructInStruct ReturnStructInStruct(int16_t a, int16_t b, int16_t c) { struct StructInStruct e = {{a}, {b}, {c}}; return e; } struct ThreeShorts{ int16_t a, b, c; }; struct ThreeShorts ReturnThreeShorts(int16_t a, int16_t b, int16_t c) { struct ThreeShorts e = {a, b, c}; return e; } struct FourShorts{ int16_t a, b, c, d; }; struct FourShorts ReturnFourShorts(int16_t a, int16_t b, int16_t c, int16_t d) { struct FourShorts e = {a, b, c, d}; return e; } struct OneLong{ int64_t a; }; struct OneLong ReturnOneLong(int64_t a) { struct OneLong e = {a}; return e; } struct TwoLongs{ int64_t a, b; }; struct TwoLongs ReturnTwoLongs(int64_t a, int64_t b) { struct TwoLongs e = {a, b}; return e; } struct ThreeLongs{ int64_t a, b, c; }; struct ThreeLongs ReturnThreeLongs(int64_t a, int64_t b, int64_t c) { struct ThreeLongs e = {a, b, c}; return e; } struct OneFloat{ float a; }; struct TwoFloats{ float a, b; }; struct TwoFloats ReturnTwoFloats(float a, float b) { struct TwoFloats e = {a-b, a*b}; return e; } struct ThreeFloats{ float a, b, c; }; struct ThreeFloats ReturnThreeFloats(float a, float b, float c) { struct ThreeFloats e = {a, b, c}; return e; } struct OneFloat ReturnOneFloat(float a) { struct OneFloat e = {a}; return e; } struct OneDouble{ double a; }; struct OneDouble ReturnOneDouble(double a) { struct OneDouble e = {a}; return e; } struct TwoDoubles{ double a, b; }; struct TwoDoubles ReturnTwoDoubles(double a, double b) { struct TwoDoubles e = {a, b}; return e; } struct ThreeDoubles{ double a, b, c; }; struct ThreeDoubles ReturnThreeDoubles(double a, double b, double c) { struct ThreeDoubles e = {a, b, c}; return e; } struct FourDoubles{ double a, b, c, d; }; struct FourDoubles ReturnFourDoubles(double a, double b, double c, double d) { struct FourDoubles e = {a, b, c, d}; return e; } struct FourDoublesInternal{ struct { double a, b; } f; struct { double c, d; } g; }; struct FourDoublesInternal ReturnFourDoublesInternal(double a, double b, double c, double d) { struct FourDoublesInternal e = { {a, b}, {c, d} }; return e; } struct FiveDoubles{ double a, b, c, d, e; }; struct FiveDoubles ReturnFiveDoubles(double a, double b, double c, double d, double e) { struct FiveDoubles s = {a, b, c, d, e}; return s; } struct OneFloatOneDouble{ float a; double b; }; struct OneFloatOneDouble ReturnOneFloatOneDouble(float a, double b) { struct OneFloatOneDouble e = {a, b}; return e; } struct OneDoubleOneFloat{ double a; float b; }; struct OneDoubleOneFloat ReturnOneDoubleOneFloat(double a, float b) { struct OneDoubleOneFloat e = {a, b}; return e; } struct Unaligned1{ int8_t a; int16_t b; int64_t c; }; struct Unaligned1 ReturnUnaligned1(int8_t a, int16_t b, int64_t c) { struct Unaligned1 e = {a, b, c}; return e; } struct Mixed1{ float a; int32_t b; }; struct Mixed1 ReturnMixed1(float a, int32_t b) { struct Mixed1 e = {a, b}; return e; } struct Mixed2{ float a; int32_t b; float c; int32_t d; }; struct Mixed2 ReturnMixed2(float a, int32_t b, float c, int32_t d) { struct Mixed2 e = {a, b, c, d}; return e; } struct Mixed3{ float a; uint32_t b; double c; }; struct Mixed3 ReturnMixed3(float a, uint32_t b, double c) { struct Mixed3 s = {a, b, c}; return s; } struct Mixed4{ double a; uint32_t b; float c; }; struct Mixed4 ReturnMixed4(double a, uint32_t b, float c) { struct Mixed4 s = {a, b, c}; return s; } struct Ptr1{ int64_t *a; void *b; }; struct Ptr1 ReturnPtr1(int64_t *a, void *b) { struct Ptr1 s = {a, b}; return s; } golang-github-ebitengine-purego-0.9.1/wincallback.go000066400000000000000000000064501512124053000224550ustar00rootroot00000000000000// Copyright 2014 The Go Authors. All rights reserved. // Use of this source code is governed by a BSD-style // license that can be found in the LICENSE file. //go:build ignore // Generate Windows callback assembly file. // This was copied from the Go repository and modified to generate non-Windows assembly files. package main import ( "bytes" "fmt" "os" ) const maxCallback = 2000 func genasmAmd64() { var buf bytes.Buffer buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. //go:build darwin || freebsd || linux || netbsd // runtime·callbackasm is called by external code to // execute Go implemented callback function. It is not // called from the start, instead runtime·compilecallback // always returns address into runtime·callbackasm offset // appropriately so different callbacks start with different // CALL instruction in runtime·callbackasm. This determines // which Go callback function is executed later on. #include "textflag.h" TEXT callbackasm(SB),NOSPLIT|NOFRAME,$0 `) for i := 0; i < maxCallback; i++ { buf.WriteString("\tCALL\tcallbackasm1(SB)\n") } if err := os.WriteFile("zcallback_amd64.s", buf.Bytes(), 0644); err != nil { fmt.Fprintf(os.Stderr, "wincallback: %s\n", err) os.Exit(2) } } func genasmArm64() { var buf bytes.Buffer buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. //go:build darwin || freebsd || linux || netbsd // External code calls into callbackasm at an offset corresponding // to the callback index. Callbackasm is a table of MOV and B instructions. // The MOV instruction loads R12 with the callback index, and the // B instruction branches to callbackasm1. // callbackasm1 takes the callback index from R12 and // indexes into an array that stores information about each callback. // It then calls the Go implementation for that callback. #include "textflag.h" TEXT callbackasm(SB),NOSPLIT|NOFRAME,$0 `) for i := 0; i < maxCallback; i++ { fmt.Fprintf(&buf, "\tMOVD\t$%d, R12\n", i) buf.WriteString("\tB\tcallbackasm1(SB)\n") } if err := os.WriteFile("zcallback_arm64.s", buf.Bytes(), 0644); err != nil { fmt.Fprintf(os.Stderr, "wincallback: %s\n", err) os.Exit(2) } } func genasmLoong64() { var buf bytes.Buffer buf.WriteString(`// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. //go:build darwin || freebsd || linux || netbsd // External code calls into callbackasm at an offset corresponding // to the callback index. Callbackasm is a table of MOVV and JMP instructions. // The MOVV instruction loads R12 with the callback index, and the // JMP instruction branches to callbackasm1. // callbackasm1 takes the callback index from R12 and // indexes into an array that stores information about each callback. // It then calls the Go implementation for that callback. #include "textflag.h" TEXT callbackasm(SB),NOSPLIT|NOFRAME,$0 `) for i := 0; i < maxCallback; i++ { fmt.Fprintf(&buf, "\tMOVV\t$%d, R13\n", i) buf.WriteString("\tJMP\tcallbackasm1(SB)\n") } if err := os.WriteFile("zcallback_loong64.s", buf.Bytes(), 0644); err != nil { fmt.Fprintf(os.Stderr, "wincallback: %s\n", err) os.Exit(2) } } func main() { genasmAmd64() genasmArm64() genasmLoong64() } golang-github-ebitengine-purego-0.9.1/zcallback_amd64.s000066400000000000000000001327701512124053000227660ustar00rootroot00000000000000// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. //go:build darwin || freebsd || linux || netbsd // runtime·callbackasm is called by external code to // execute Go implemented callback function. It is not // called from the start, instead runtime·compilecallback // always returns address into runtime·callbackasm offset // appropriately so different callbacks start with different // CALL instruction in runtime·callbackasm. This determines // which Go callback function is executed later on. #include "textflag.h" TEXT callbackasm(SB),NOSPLIT|NOFRAME,$0 CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) CALL callbackasm1(SB) golang-github-ebitengine-purego-0.9.1/zcallback_arm64.s000066400000000000000000002174431512124053000230050ustar00rootroot00000000000000// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. //go:build darwin || freebsd || linux || netbsd // External code calls into callbackasm at an offset corresponding // to the callback index. Callbackasm is a table of MOV and B instructions. // The MOV instruction loads R12 with the callback index, and the // B instruction branches to callbackasm1. // callbackasm1 takes the callback index from R12 and // indexes into an array that stores information about each callback. // It then calls the Go implementation for that callback. #include "textflag.h" TEXT callbackasm(SB),NOSPLIT|NOFRAME,$0 MOVD $0, R12 B callbackasm1(SB) MOVD $1, R12 B callbackasm1(SB) MOVD $2, R12 B callbackasm1(SB) MOVD $3, R12 B callbackasm1(SB) MOVD $4, R12 B callbackasm1(SB) MOVD $5, R12 B callbackasm1(SB) MOVD $6, R12 B callbackasm1(SB) MOVD $7, R12 B callbackasm1(SB) MOVD $8, R12 B callbackasm1(SB) MOVD $9, R12 B callbackasm1(SB) MOVD $10, R12 B callbackasm1(SB) MOVD $11, R12 B callbackasm1(SB) MOVD $12, R12 B callbackasm1(SB) MOVD $13, R12 B callbackasm1(SB) MOVD $14, R12 B callbackasm1(SB) MOVD $15, R12 B callbackasm1(SB) MOVD $16, R12 B callbackasm1(SB) MOVD $17, R12 B callbackasm1(SB) MOVD $18, R12 B callbackasm1(SB) MOVD $19, R12 B callbackasm1(SB) MOVD $20, R12 B callbackasm1(SB) MOVD $21, R12 B callbackasm1(SB) MOVD $22, R12 B callbackasm1(SB) MOVD $23, R12 B callbackasm1(SB) MOVD $24, R12 B callbackasm1(SB) MOVD $25, R12 B callbackasm1(SB) MOVD $26, R12 B callbackasm1(SB) MOVD $27, R12 B callbackasm1(SB) MOVD $28, R12 B callbackasm1(SB) MOVD $29, R12 B callbackasm1(SB) MOVD $30, R12 B callbackasm1(SB) MOVD $31, R12 B callbackasm1(SB) MOVD $32, R12 B callbackasm1(SB) MOVD $33, R12 B callbackasm1(SB) MOVD $34, R12 B callbackasm1(SB) MOVD $35, R12 B callbackasm1(SB) MOVD $36, R12 B callbackasm1(SB) MOVD $37, R12 B callbackasm1(SB) MOVD $38, R12 B callbackasm1(SB) MOVD $39, R12 B callbackasm1(SB) MOVD $40, R12 B callbackasm1(SB) MOVD $41, R12 B callbackasm1(SB) MOVD $42, R12 B callbackasm1(SB) MOVD $43, R12 B callbackasm1(SB) MOVD $44, R12 B callbackasm1(SB) MOVD $45, R12 B callbackasm1(SB) MOVD $46, R12 B callbackasm1(SB) MOVD $47, R12 B callbackasm1(SB) MOVD $48, R12 B callbackasm1(SB) MOVD $49, R12 B callbackasm1(SB) MOVD $50, R12 B callbackasm1(SB) MOVD $51, R12 B callbackasm1(SB) MOVD $52, R12 B callbackasm1(SB) MOVD $53, R12 B callbackasm1(SB) MOVD $54, R12 B callbackasm1(SB) MOVD $55, R12 B callbackasm1(SB) MOVD $56, R12 B callbackasm1(SB) MOVD $57, R12 B callbackasm1(SB) MOVD $58, R12 B callbackasm1(SB) MOVD $59, R12 B callbackasm1(SB) MOVD $60, R12 B callbackasm1(SB) MOVD $61, R12 B callbackasm1(SB) MOVD $62, R12 B callbackasm1(SB) MOVD $63, R12 B callbackasm1(SB) MOVD $64, R12 B callbackasm1(SB) MOVD $65, R12 B callbackasm1(SB) MOVD $66, R12 B callbackasm1(SB) MOVD $67, R12 B callbackasm1(SB) MOVD $68, R12 B callbackasm1(SB) MOVD $69, R12 B callbackasm1(SB) MOVD $70, R12 B callbackasm1(SB) MOVD $71, R12 B callbackasm1(SB) MOVD $72, R12 B callbackasm1(SB) MOVD $73, R12 B callbackasm1(SB) MOVD $74, R12 B callbackasm1(SB) MOVD $75, R12 B callbackasm1(SB) MOVD $76, R12 B callbackasm1(SB) MOVD $77, R12 B callbackasm1(SB) MOVD $78, R12 B callbackasm1(SB) MOVD $79, R12 B callbackasm1(SB) MOVD $80, R12 B callbackasm1(SB) MOVD $81, R12 B callbackasm1(SB) MOVD $82, R12 B callbackasm1(SB) MOVD $83, R12 B callbackasm1(SB) MOVD $84, R12 B callbackasm1(SB) MOVD $85, R12 B callbackasm1(SB) MOVD $86, R12 B callbackasm1(SB) MOVD $87, R12 B callbackasm1(SB) MOVD $88, R12 B callbackasm1(SB) MOVD $89, R12 B callbackasm1(SB) MOVD $90, R12 B callbackasm1(SB) MOVD $91, R12 B callbackasm1(SB) MOVD $92, R12 B callbackasm1(SB) MOVD $93, R12 B callbackasm1(SB) MOVD $94, R12 B callbackasm1(SB) MOVD $95, R12 B callbackasm1(SB) MOVD $96, R12 B callbackasm1(SB) MOVD $97, R12 B callbackasm1(SB) MOVD $98, R12 B callbackasm1(SB) MOVD $99, R12 B callbackasm1(SB) MOVD $100, R12 B callbackasm1(SB) MOVD $101, R12 B callbackasm1(SB) MOVD $102, R12 B callbackasm1(SB) MOVD $103, R12 B callbackasm1(SB) MOVD $104, R12 B callbackasm1(SB) MOVD $105, R12 B callbackasm1(SB) MOVD $106, R12 B callbackasm1(SB) MOVD $107, R12 B callbackasm1(SB) MOVD $108, R12 B callbackasm1(SB) MOVD $109, R12 B callbackasm1(SB) MOVD $110, R12 B callbackasm1(SB) MOVD $111, R12 B callbackasm1(SB) MOVD $112, R12 B callbackasm1(SB) MOVD $113, R12 B callbackasm1(SB) MOVD $114, R12 B callbackasm1(SB) MOVD $115, R12 B callbackasm1(SB) MOVD $116, R12 B callbackasm1(SB) MOVD $117, R12 B callbackasm1(SB) MOVD $118, R12 B callbackasm1(SB) MOVD $119, R12 B callbackasm1(SB) MOVD $120, R12 B callbackasm1(SB) MOVD $121, R12 B callbackasm1(SB) MOVD $122, R12 B callbackasm1(SB) MOVD $123, R12 B callbackasm1(SB) MOVD $124, R12 B callbackasm1(SB) MOVD $125, R12 B callbackasm1(SB) MOVD $126, R12 B callbackasm1(SB) MOVD $127, R12 B callbackasm1(SB) MOVD $128, R12 B callbackasm1(SB) MOVD $129, R12 B callbackasm1(SB) MOVD $130, R12 B callbackasm1(SB) MOVD $131, R12 B callbackasm1(SB) MOVD $132, R12 B callbackasm1(SB) MOVD $133, R12 B callbackasm1(SB) MOVD $134, R12 B callbackasm1(SB) MOVD $135, R12 B callbackasm1(SB) MOVD $136, R12 B callbackasm1(SB) MOVD $137, R12 B callbackasm1(SB) MOVD $138, R12 B callbackasm1(SB) MOVD $139, R12 B callbackasm1(SB) MOVD $140, R12 B callbackasm1(SB) MOVD $141, R12 B callbackasm1(SB) MOVD $142, R12 B callbackasm1(SB) MOVD $143, R12 B callbackasm1(SB) MOVD $144, R12 B callbackasm1(SB) MOVD $145, R12 B callbackasm1(SB) MOVD $146, R12 B callbackasm1(SB) MOVD $147, R12 B callbackasm1(SB) MOVD $148, R12 B callbackasm1(SB) MOVD $149, R12 B callbackasm1(SB) MOVD $150, R12 B callbackasm1(SB) MOVD $151, R12 B callbackasm1(SB) MOVD $152, R12 B callbackasm1(SB) MOVD $153, R12 B callbackasm1(SB) MOVD $154, R12 B callbackasm1(SB) MOVD $155, R12 B callbackasm1(SB) MOVD $156, R12 B callbackasm1(SB) MOVD $157, R12 B callbackasm1(SB) MOVD $158, R12 B callbackasm1(SB) MOVD $159, R12 B callbackasm1(SB) MOVD $160, R12 B callbackasm1(SB) MOVD $161, R12 B callbackasm1(SB) MOVD $162, R12 B callbackasm1(SB) MOVD $163, R12 B callbackasm1(SB) MOVD $164, R12 B callbackasm1(SB) MOVD $165, R12 B callbackasm1(SB) MOVD $166, R12 B callbackasm1(SB) MOVD $167, R12 B callbackasm1(SB) MOVD $168, R12 B callbackasm1(SB) MOVD $169, R12 B callbackasm1(SB) MOVD $170, R12 B callbackasm1(SB) MOVD $171, R12 B callbackasm1(SB) MOVD $172, R12 B callbackasm1(SB) MOVD $173, R12 B callbackasm1(SB) MOVD $174, R12 B callbackasm1(SB) MOVD $175, R12 B callbackasm1(SB) MOVD $176, R12 B callbackasm1(SB) MOVD $177, R12 B callbackasm1(SB) MOVD $178, R12 B callbackasm1(SB) MOVD $179, R12 B callbackasm1(SB) MOVD $180, R12 B callbackasm1(SB) MOVD $181, R12 B callbackasm1(SB) MOVD $182, R12 B callbackasm1(SB) MOVD $183, R12 B callbackasm1(SB) MOVD $184, R12 B callbackasm1(SB) MOVD $185, R12 B callbackasm1(SB) MOVD $186, R12 B callbackasm1(SB) MOVD $187, R12 B callbackasm1(SB) MOVD $188, R12 B callbackasm1(SB) MOVD $189, R12 B callbackasm1(SB) MOVD $190, R12 B callbackasm1(SB) MOVD $191, R12 B callbackasm1(SB) MOVD $192, R12 B callbackasm1(SB) MOVD $193, R12 B callbackasm1(SB) MOVD $194, R12 B callbackasm1(SB) MOVD $195, R12 B callbackasm1(SB) MOVD $196, R12 B callbackasm1(SB) MOVD $197, R12 B callbackasm1(SB) MOVD $198, R12 B callbackasm1(SB) MOVD $199, R12 B callbackasm1(SB) MOVD $200, R12 B callbackasm1(SB) MOVD $201, R12 B callbackasm1(SB) MOVD $202, R12 B callbackasm1(SB) MOVD $203, R12 B callbackasm1(SB) MOVD $204, R12 B callbackasm1(SB) MOVD $205, R12 B callbackasm1(SB) MOVD $206, R12 B callbackasm1(SB) MOVD $207, R12 B callbackasm1(SB) MOVD $208, R12 B callbackasm1(SB) MOVD $209, R12 B callbackasm1(SB) MOVD $210, R12 B callbackasm1(SB) MOVD $211, R12 B callbackasm1(SB) MOVD $212, R12 B callbackasm1(SB) MOVD $213, R12 B callbackasm1(SB) MOVD $214, R12 B callbackasm1(SB) MOVD $215, R12 B callbackasm1(SB) MOVD $216, R12 B callbackasm1(SB) MOVD $217, R12 B callbackasm1(SB) MOVD $218, R12 B callbackasm1(SB) MOVD $219, R12 B callbackasm1(SB) MOVD $220, R12 B callbackasm1(SB) MOVD $221, R12 B callbackasm1(SB) MOVD $222, R12 B callbackasm1(SB) MOVD $223, R12 B callbackasm1(SB) MOVD $224, R12 B callbackasm1(SB) MOVD $225, R12 B callbackasm1(SB) MOVD $226, R12 B callbackasm1(SB) MOVD $227, R12 B callbackasm1(SB) MOVD $228, R12 B callbackasm1(SB) MOVD $229, R12 B callbackasm1(SB) MOVD $230, R12 B callbackasm1(SB) MOVD $231, R12 B callbackasm1(SB) MOVD $232, R12 B callbackasm1(SB) MOVD $233, R12 B callbackasm1(SB) MOVD $234, R12 B callbackasm1(SB) MOVD $235, R12 B callbackasm1(SB) MOVD $236, R12 B callbackasm1(SB) MOVD $237, R12 B callbackasm1(SB) MOVD $238, R12 B callbackasm1(SB) MOVD $239, R12 B callbackasm1(SB) MOVD $240, R12 B callbackasm1(SB) MOVD $241, R12 B callbackasm1(SB) MOVD $242, R12 B callbackasm1(SB) MOVD $243, R12 B callbackasm1(SB) MOVD $244, R12 B callbackasm1(SB) MOVD $245, R12 B callbackasm1(SB) MOVD $246, R12 B callbackasm1(SB) MOVD $247, R12 B callbackasm1(SB) MOVD $248, R12 B callbackasm1(SB) MOVD $249, R12 B callbackasm1(SB) MOVD $250, R12 B callbackasm1(SB) MOVD $251, R12 B callbackasm1(SB) MOVD $252, R12 B callbackasm1(SB) MOVD $253, R12 B callbackasm1(SB) MOVD $254, R12 B callbackasm1(SB) MOVD $255, R12 B callbackasm1(SB) MOVD $256, R12 B callbackasm1(SB) MOVD $257, R12 B callbackasm1(SB) MOVD $258, R12 B callbackasm1(SB) MOVD $259, R12 B callbackasm1(SB) MOVD $260, R12 B callbackasm1(SB) MOVD $261, R12 B callbackasm1(SB) MOVD $262, R12 B callbackasm1(SB) MOVD $263, R12 B callbackasm1(SB) MOVD $264, R12 B callbackasm1(SB) MOVD $265, R12 B callbackasm1(SB) MOVD $266, R12 B callbackasm1(SB) MOVD $267, R12 B callbackasm1(SB) MOVD $268, R12 B callbackasm1(SB) MOVD $269, R12 B callbackasm1(SB) MOVD $270, R12 B callbackasm1(SB) MOVD $271, R12 B callbackasm1(SB) MOVD $272, R12 B callbackasm1(SB) MOVD $273, R12 B callbackasm1(SB) MOVD $274, R12 B callbackasm1(SB) MOVD $275, R12 B callbackasm1(SB) MOVD $276, R12 B callbackasm1(SB) MOVD $277, R12 B callbackasm1(SB) MOVD $278, R12 B callbackasm1(SB) MOVD $279, R12 B callbackasm1(SB) MOVD $280, R12 B callbackasm1(SB) MOVD $281, R12 B callbackasm1(SB) MOVD $282, R12 B callbackasm1(SB) MOVD $283, R12 B callbackasm1(SB) MOVD $284, R12 B callbackasm1(SB) MOVD $285, R12 B callbackasm1(SB) MOVD $286, R12 B callbackasm1(SB) MOVD $287, R12 B callbackasm1(SB) MOVD $288, R12 B callbackasm1(SB) MOVD $289, R12 B callbackasm1(SB) MOVD $290, R12 B callbackasm1(SB) MOVD $291, R12 B callbackasm1(SB) MOVD $292, R12 B callbackasm1(SB) MOVD $293, R12 B callbackasm1(SB) MOVD $294, R12 B callbackasm1(SB) MOVD $295, R12 B callbackasm1(SB) MOVD $296, R12 B callbackasm1(SB) MOVD $297, R12 B callbackasm1(SB) MOVD $298, R12 B callbackasm1(SB) MOVD $299, R12 B callbackasm1(SB) MOVD $300, R12 B callbackasm1(SB) MOVD $301, R12 B callbackasm1(SB) MOVD $302, R12 B callbackasm1(SB) MOVD $303, R12 B callbackasm1(SB) MOVD $304, R12 B callbackasm1(SB) MOVD $305, R12 B callbackasm1(SB) MOVD $306, R12 B callbackasm1(SB) MOVD $307, R12 B callbackasm1(SB) MOVD $308, R12 B callbackasm1(SB) MOVD $309, R12 B callbackasm1(SB) MOVD $310, R12 B callbackasm1(SB) MOVD $311, R12 B callbackasm1(SB) MOVD $312, R12 B callbackasm1(SB) MOVD $313, R12 B callbackasm1(SB) MOVD $314, R12 B callbackasm1(SB) MOVD $315, R12 B callbackasm1(SB) MOVD $316, R12 B callbackasm1(SB) MOVD $317, R12 B callbackasm1(SB) MOVD $318, R12 B callbackasm1(SB) MOVD $319, R12 B callbackasm1(SB) MOVD $320, R12 B callbackasm1(SB) MOVD $321, R12 B callbackasm1(SB) MOVD $322, R12 B callbackasm1(SB) MOVD $323, R12 B callbackasm1(SB) MOVD $324, R12 B callbackasm1(SB) MOVD $325, R12 B callbackasm1(SB) MOVD $326, R12 B callbackasm1(SB) MOVD $327, R12 B callbackasm1(SB) MOVD $328, R12 B callbackasm1(SB) MOVD $329, R12 B callbackasm1(SB) MOVD $330, R12 B callbackasm1(SB) MOVD $331, R12 B callbackasm1(SB) MOVD $332, R12 B callbackasm1(SB) MOVD $333, R12 B callbackasm1(SB) MOVD $334, R12 B callbackasm1(SB) MOVD $335, R12 B callbackasm1(SB) MOVD $336, R12 B callbackasm1(SB) MOVD $337, R12 B callbackasm1(SB) MOVD $338, R12 B callbackasm1(SB) MOVD $339, R12 B callbackasm1(SB) MOVD $340, R12 B callbackasm1(SB) MOVD $341, R12 B callbackasm1(SB) MOVD $342, R12 B callbackasm1(SB) MOVD $343, R12 B callbackasm1(SB) MOVD $344, R12 B callbackasm1(SB) MOVD $345, R12 B callbackasm1(SB) MOVD $346, R12 B callbackasm1(SB) MOVD $347, R12 B callbackasm1(SB) MOVD $348, R12 B callbackasm1(SB) MOVD $349, R12 B callbackasm1(SB) MOVD $350, R12 B callbackasm1(SB) MOVD $351, R12 B callbackasm1(SB) MOVD $352, R12 B callbackasm1(SB) MOVD $353, R12 B callbackasm1(SB) MOVD $354, R12 B callbackasm1(SB) MOVD $355, R12 B callbackasm1(SB) MOVD $356, R12 B callbackasm1(SB) MOVD $357, R12 B callbackasm1(SB) MOVD $358, R12 B callbackasm1(SB) MOVD $359, R12 B callbackasm1(SB) MOVD $360, R12 B callbackasm1(SB) MOVD $361, R12 B callbackasm1(SB) MOVD $362, R12 B callbackasm1(SB) MOVD $363, R12 B callbackasm1(SB) MOVD $364, R12 B callbackasm1(SB) MOVD $365, R12 B callbackasm1(SB) MOVD $366, R12 B callbackasm1(SB) MOVD $367, R12 B callbackasm1(SB) MOVD $368, R12 B callbackasm1(SB) MOVD $369, R12 B callbackasm1(SB) MOVD $370, R12 B callbackasm1(SB) MOVD $371, R12 B callbackasm1(SB) MOVD $372, R12 B callbackasm1(SB) MOVD $373, R12 B callbackasm1(SB) MOVD $374, R12 B callbackasm1(SB) MOVD $375, R12 B callbackasm1(SB) MOVD $376, R12 B callbackasm1(SB) MOVD $377, R12 B callbackasm1(SB) MOVD $378, R12 B callbackasm1(SB) MOVD $379, R12 B callbackasm1(SB) MOVD $380, R12 B callbackasm1(SB) MOVD $381, R12 B callbackasm1(SB) MOVD $382, R12 B callbackasm1(SB) MOVD $383, R12 B callbackasm1(SB) MOVD $384, R12 B callbackasm1(SB) MOVD $385, R12 B callbackasm1(SB) MOVD $386, R12 B callbackasm1(SB) MOVD $387, R12 B callbackasm1(SB) MOVD $388, R12 B callbackasm1(SB) MOVD $389, R12 B callbackasm1(SB) MOVD $390, R12 B callbackasm1(SB) MOVD $391, R12 B callbackasm1(SB) MOVD $392, R12 B callbackasm1(SB) MOVD $393, R12 B callbackasm1(SB) MOVD $394, R12 B callbackasm1(SB) MOVD $395, R12 B callbackasm1(SB) MOVD $396, R12 B callbackasm1(SB) MOVD $397, R12 B callbackasm1(SB) MOVD $398, R12 B callbackasm1(SB) MOVD $399, R12 B callbackasm1(SB) MOVD $400, R12 B callbackasm1(SB) MOVD $401, R12 B callbackasm1(SB) MOVD $402, R12 B callbackasm1(SB) MOVD $403, R12 B callbackasm1(SB) MOVD $404, R12 B callbackasm1(SB) MOVD $405, R12 B callbackasm1(SB) MOVD $406, R12 B callbackasm1(SB) MOVD $407, R12 B callbackasm1(SB) MOVD $408, R12 B callbackasm1(SB) MOVD $409, R12 B callbackasm1(SB) MOVD $410, R12 B callbackasm1(SB) MOVD $411, R12 B callbackasm1(SB) MOVD $412, R12 B callbackasm1(SB) MOVD $413, R12 B callbackasm1(SB) MOVD $414, R12 B callbackasm1(SB) MOVD $415, R12 B callbackasm1(SB) MOVD $416, R12 B callbackasm1(SB) MOVD $417, R12 B callbackasm1(SB) MOVD $418, R12 B callbackasm1(SB) MOVD $419, R12 B callbackasm1(SB) MOVD $420, R12 B callbackasm1(SB) MOVD $421, R12 B callbackasm1(SB) MOVD $422, R12 B callbackasm1(SB) MOVD $423, R12 B callbackasm1(SB) MOVD $424, R12 B callbackasm1(SB) MOVD $425, R12 B callbackasm1(SB) MOVD $426, R12 B callbackasm1(SB) MOVD $427, R12 B callbackasm1(SB) MOVD $428, R12 B callbackasm1(SB) MOVD $429, R12 B callbackasm1(SB) MOVD $430, R12 B callbackasm1(SB) MOVD $431, R12 B callbackasm1(SB) MOVD $432, R12 B callbackasm1(SB) MOVD $433, R12 B callbackasm1(SB) MOVD $434, R12 B callbackasm1(SB) MOVD $435, R12 B callbackasm1(SB) MOVD $436, R12 B callbackasm1(SB) MOVD $437, R12 B callbackasm1(SB) MOVD $438, R12 B callbackasm1(SB) MOVD $439, R12 B callbackasm1(SB) MOVD $440, R12 B callbackasm1(SB) MOVD $441, R12 B callbackasm1(SB) MOVD $442, R12 B callbackasm1(SB) MOVD $443, R12 B callbackasm1(SB) MOVD $444, R12 B callbackasm1(SB) MOVD $445, R12 B callbackasm1(SB) MOVD $446, R12 B callbackasm1(SB) MOVD $447, R12 B callbackasm1(SB) MOVD $448, R12 B callbackasm1(SB) MOVD $449, R12 B callbackasm1(SB) MOVD $450, R12 B callbackasm1(SB) MOVD $451, R12 B callbackasm1(SB) MOVD $452, R12 B callbackasm1(SB) MOVD $453, R12 B callbackasm1(SB) MOVD $454, R12 B callbackasm1(SB) MOVD $455, R12 B callbackasm1(SB) MOVD $456, R12 B callbackasm1(SB) MOVD $457, R12 B callbackasm1(SB) MOVD $458, R12 B callbackasm1(SB) MOVD $459, R12 B callbackasm1(SB) MOVD $460, R12 B callbackasm1(SB) MOVD $461, R12 B callbackasm1(SB) MOVD $462, R12 B callbackasm1(SB) MOVD $463, R12 B callbackasm1(SB) MOVD $464, R12 B callbackasm1(SB) MOVD $465, R12 B callbackasm1(SB) MOVD $466, R12 B callbackasm1(SB) MOVD $467, R12 B callbackasm1(SB) MOVD $468, R12 B callbackasm1(SB) MOVD $469, R12 B callbackasm1(SB) MOVD $470, R12 B callbackasm1(SB) MOVD $471, R12 B callbackasm1(SB) MOVD $472, R12 B callbackasm1(SB) MOVD $473, R12 B callbackasm1(SB) MOVD $474, R12 B callbackasm1(SB) MOVD $475, R12 B callbackasm1(SB) MOVD $476, R12 B callbackasm1(SB) MOVD $477, R12 B callbackasm1(SB) MOVD $478, R12 B callbackasm1(SB) MOVD $479, R12 B callbackasm1(SB) MOVD $480, R12 B callbackasm1(SB) MOVD $481, R12 B callbackasm1(SB) MOVD $482, R12 B callbackasm1(SB) MOVD $483, R12 B callbackasm1(SB) MOVD $484, R12 B callbackasm1(SB) MOVD $485, R12 B callbackasm1(SB) MOVD $486, R12 B callbackasm1(SB) MOVD $487, R12 B callbackasm1(SB) MOVD $488, R12 B callbackasm1(SB) MOVD $489, R12 B callbackasm1(SB) MOVD $490, R12 B callbackasm1(SB) MOVD $491, R12 B callbackasm1(SB) MOVD $492, R12 B callbackasm1(SB) MOVD $493, R12 B callbackasm1(SB) MOVD $494, R12 B callbackasm1(SB) MOVD $495, R12 B callbackasm1(SB) MOVD $496, R12 B callbackasm1(SB) MOVD $497, R12 B callbackasm1(SB) MOVD $498, R12 B callbackasm1(SB) MOVD $499, R12 B callbackasm1(SB) MOVD $500, R12 B callbackasm1(SB) MOVD $501, R12 B callbackasm1(SB) MOVD $502, R12 B callbackasm1(SB) MOVD $503, R12 B callbackasm1(SB) MOVD $504, R12 B callbackasm1(SB) MOVD $505, R12 B callbackasm1(SB) MOVD $506, R12 B callbackasm1(SB) MOVD $507, R12 B callbackasm1(SB) MOVD $508, R12 B callbackasm1(SB) MOVD $509, R12 B callbackasm1(SB) MOVD $510, R12 B callbackasm1(SB) MOVD $511, R12 B callbackasm1(SB) MOVD $512, R12 B callbackasm1(SB) MOVD $513, R12 B callbackasm1(SB) MOVD $514, R12 B callbackasm1(SB) MOVD $515, R12 B callbackasm1(SB) MOVD $516, R12 B callbackasm1(SB) MOVD $517, R12 B callbackasm1(SB) MOVD $518, R12 B callbackasm1(SB) MOVD $519, R12 B callbackasm1(SB) MOVD $520, R12 B callbackasm1(SB) MOVD $521, R12 B callbackasm1(SB) MOVD $522, R12 B callbackasm1(SB) MOVD $523, R12 B callbackasm1(SB) MOVD $524, R12 B callbackasm1(SB) MOVD $525, R12 B callbackasm1(SB) MOVD $526, R12 B callbackasm1(SB) MOVD $527, R12 B callbackasm1(SB) MOVD $528, R12 B callbackasm1(SB) MOVD $529, R12 B callbackasm1(SB) MOVD $530, R12 B callbackasm1(SB) MOVD $531, R12 B callbackasm1(SB) MOVD $532, R12 B callbackasm1(SB) MOVD $533, R12 B callbackasm1(SB) MOVD $534, R12 B callbackasm1(SB) MOVD $535, R12 B callbackasm1(SB) MOVD $536, R12 B callbackasm1(SB) MOVD $537, R12 B callbackasm1(SB) MOVD $538, R12 B callbackasm1(SB) MOVD $539, R12 B callbackasm1(SB) MOVD $540, R12 B callbackasm1(SB) MOVD $541, R12 B callbackasm1(SB) MOVD $542, R12 B callbackasm1(SB) MOVD $543, R12 B callbackasm1(SB) MOVD $544, R12 B callbackasm1(SB) MOVD $545, R12 B callbackasm1(SB) MOVD $546, R12 B callbackasm1(SB) MOVD $547, R12 B callbackasm1(SB) MOVD $548, R12 B callbackasm1(SB) MOVD $549, R12 B callbackasm1(SB) MOVD $550, R12 B callbackasm1(SB) MOVD $551, R12 B callbackasm1(SB) MOVD $552, R12 B callbackasm1(SB) MOVD $553, R12 B callbackasm1(SB) MOVD $554, R12 B callbackasm1(SB) MOVD $555, R12 B callbackasm1(SB) MOVD $556, R12 B callbackasm1(SB) MOVD $557, R12 B callbackasm1(SB) MOVD $558, R12 B callbackasm1(SB) MOVD $559, R12 B callbackasm1(SB) MOVD $560, R12 B callbackasm1(SB) MOVD $561, R12 B callbackasm1(SB) MOVD $562, R12 B callbackasm1(SB) MOVD $563, R12 B callbackasm1(SB) MOVD $564, R12 B callbackasm1(SB) MOVD $565, R12 B callbackasm1(SB) MOVD $566, R12 B callbackasm1(SB) MOVD $567, R12 B callbackasm1(SB) MOVD $568, R12 B callbackasm1(SB) MOVD $569, R12 B callbackasm1(SB) MOVD $570, R12 B callbackasm1(SB) MOVD $571, R12 B callbackasm1(SB) MOVD $572, R12 B callbackasm1(SB) MOVD $573, R12 B callbackasm1(SB) MOVD $574, R12 B callbackasm1(SB) MOVD $575, R12 B callbackasm1(SB) MOVD $576, R12 B callbackasm1(SB) MOVD $577, R12 B callbackasm1(SB) MOVD $578, R12 B callbackasm1(SB) MOVD $579, R12 B callbackasm1(SB) MOVD $580, R12 B callbackasm1(SB) MOVD $581, R12 B callbackasm1(SB) MOVD $582, R12 B callbackasm1(SB) MOVD $583, R12 B callbackasm1(SB) MOVD $584, R12 B callbackasm1(SB) MOVD $585, R12 B callbackasm1(SB) MOVD $586, R12 B callbackasm1(SB) MOVD $587, R12 B callbackasm1(SB) MOVD $588, R12 B callbackasm1(SB) MOVD $589, R12 B callbackasm1(SB) MOVD $590, R12 B callbackasm1(SB) MOVD $591, R12 B callbackasm1(SB) MOVD $592, R12 B callbackasm1(SB) MOVD $593, R12 B callbackasm1(SB) MOVD $594, R12 B callbackasm1(SB) MOVD $595, R12 B callbackasm1(SB) MOVD $596, R12 B callbackasm1(SB) MOVD $597, R12 B callbackasm1(SB) MOVD $598, R12 B callbackasm1(SB) MOVD $599, R12 B callbackasm1(SB) MOVD $600, R12 B callbackasm1(SB) MOVD $601, R12 B callbackasm1(SB) MOVD $602, R12 B callbackasm1(SB) MOVD $603, R12 B callbackasm1(SB) MOVD $604, R12 B callbackasm1(SB) MOVD $605, R12 B callbackasm1(SB) MOVD $606, R12 B callbackasm1(SB) MOVD $607, R12 B callbackasm1(SB) MOVD $608, R12 B callbackasm1(SB) MOVD $609, R12 B callbackasm1(SB) MOVD $610, R12 B callbackasm1(SB) MOVD $611, R12 B callbackasm1(SB) MOVD $612, R12 B callbackasm1(SB) MOVD $613, R12 B callbackasm1(SB) MOVD $614, R12 B callbackasm1(SB) MOVD $615, R12 B callbackasm1(SB) MOVD $616, R12 B callbackasm1(SB) MOVD $617, R12 B callbackasm1(SB) MOVD $618, R12 B callbackasm1(SB) MOVD $619, R12 B callbackasm1(SB) MOVD $620, R12 B callbackasm1(SB) MOVD $621, R12 B callbackasm1(SB) MOVD $622, R12 B callbackasm1(SB) MOVD $623, R12 B callbackasm1(SB) MOVD $624, R12 B callbackasm1(SB) MOVD $625, R12 B callbackasm1(SB) MOVD $626, R12 B callbackasm1(SB) MOVD $627, R12 B callbackasm1(SB) MOVD $628, R12 B callbackasm1(SB) MOVD $629, R12 B callbackasm1(SB) MOVD $630, R12 B callbackasm1(SB) MOVD $631, R12 B callbackasm1(SB) MOVD $632, R12 B callbackasm1(SB) MOVD $633, R12 B callbackasm1(SB) MOVD $634, R12 B callbackasm1(SB) MOVD $635, R12 B callbackasm1(SB) MOVD $636, R12 B callbackasm1(SB) MOVD $637, R12 B callbackasm1(SB) MOVD $638, R12 B callbackasm1(SB) MOVD $639, R12 B callbackasm1(SB) MOVD $640, R12 B callbackasm1(SB) MOVD $641, R12 B callbackasm1(SB) MOVD $642, R12 B callbackasm1(SB) MOVD $643, R12 B callbackasm1(SB) MOVD $644, R12 B callbackasm1(SB) MOVD $645, R12 B callbackasm1(SB) MOVD $646, R12 B callbackasm1(SB) MOVD $647, R12 B callbackasm1(SB) MOVD $648, R12 B callbackasm1(SB) MOVD $649, R12 B callbackasm1(SB) MOVD $650, R12 B callbackasm1(SB) MOVD $651, R12 B callbackasm1(SB) MOVD $652, R12 B callbackasm1(SB) MOVD $653, R12 B callbackasm1(SB) MOVD $654, R12 B callbackasm1(SB) MOVD $655, R12 B callbackasm1(SB) MOVD $656, R12 B callbackasm1(SB) MOVD $657, R12 B callbackasm1(SB) MOVD $658, R12 B callbackasm1(SB) MOVD $659, R12 B callbackasm1(SB) MOVD $660, R12 B callbackasm1(SB) MOVD $661, R12 B callbackasm1(SB) MOVD $662, R12 B callbackasm1(SB) MOVD $663, R12 B callbackasm1(SB) MOVD $664, R12 B callbackasm1(SB) MOVD $665, R12 B callbackasm1(SB) MOVD $666, R12 B callbackasm1(SB) MOVD $667, R12 B callbackasm1(SB) MOVD $668, R12 B callbackasm1(SB) MOVD $669, R12 B callbackasm1(SB) MOVD $670, R12 B callbackasm1(SB) MOVD $671, R12 B callbackasm1(SB) MOVD $672, R12 B callbackasm1(SB) MOVD $673, R12 B callbackasm1(SB) MOVD $674, R12 B callbackasm1(SB) MOVD $675, R12 B callbackasm1(SB) MOVD $676, R12 B callbackasm1(SB) MOVD $677, R12 B callbackasm1(SB) MOVD $678, R12 B callbackasm1(SB) MOVD $679, R12 B callbackasm1(SB) MOVD $680, R12 B callbackasm1(SB) MOVD $681, R12 B callbackasm1(SB) MOVD $682, R12 B callbackasm1(SB) MOVD $683, R12 B callbackasm1(SB) MOVD $684, R12 B callbackasm1(SB) MOVD $685, R12 B callbackasm1(SB) MOVD $686, R12 B callbackasm1(SB) MOVD $687, R12 B callbackasm1(SB) MOVD $688, R12 B callbackasm1(SB) MOVD $689, R12 B callbackasm1(SB) MOVD $690, R12 B callbackasm1(SB) MOVD $691, R12 B callbackasm1(SB) MOVD $692, R12 B callbackasm1(SB) MOVD $693, R12 B callbackasm1(SB) MOVD $694, R12 B callbackasm1(SB) MOVD $695, R12 B callbackasm1(SB) MOVD $696, R12 B callbackasm1(SB) MOVD $697, R12 B callbackasm1(SB) MOVD $698, R12 B callbackasm1(SB) MOVD $699, R12 B callbackasm1(SB) MOVD $700, R12 B callbackasm1(SB) MOVD $701, R12 B callbackasm1(SB) MOVD $702, R12 B callbackasm1(SB) MOVD $703, R12 B callbackasm1(SB) MOVD $704, R12 B callbackasm1(SB) MOVD $705, R12 B callbackasm1(SB) MOVD $706, R12 B callbackasm1(SB) MOVD $707, R12 B callbackasm1(SB) MOVD $708, R12 B callbackasm1(SB) MOVD $709, R12 B callbackasm1(SB) MOVD $710, R12 B callbackasm1(SB) MOVD $711, R12 B callbackasm1(SB) MOVD $712, R12 B callbackasm1(SB) MOVD $713, R12 B callbackasm1(SB) MOVD $714, R12 B callbackasm1(SB) MOVD $715, R12 B callbackasm1(SB) MOVD $716, R12 B callbackasm1(SB) MOVD $717, R12 B callbackasm1(SB) MOVD $718, R12 B callbackasm1(SB) MOVD $719, R12 B callbackasm1(SB) MOVD $720, R12 B callbackasm1(SB) MOVD $721, R12 B callbackasm1(SB) MOVD $722, R12 B callbackasm1(SB) MOVD $723, R12 B callbackasm1(SB) MOVD $724, R12 B callbackasm1(SB) MOVD $725, R12 B callbackasm1(SB) MOVD $726, R12 B callbackasm1(SB) MOVD $727, R12 B callbackasm1(SB) MOVD $728, R12 B callbackasm1(SB) MOVD $729, R12 B callbackasm1(SB) MOVD $730, R12 B callbackasm1(SB) MOVD $731, R12 B callbackasm1(SB) MOVD $732, R12 B callbackasm1(SB) MOVD $733, R12 B callbackasm1(SB) MOVD $734, R12 B callbackasm1(SB) MOVD $735, R12 B callbackasm1(SB) MOVD $736, R12 B callbackasm1(SB) MOVD $737, R12 B callbackasm1(SB) MOVD $738, R12 B callbackasm1(SB) MOVD $739, R12 B callbackasm1(SB) MOVD $740, R12 B callbackasm1(SB) MOVD $741, R12 B callbackasm1(SB) MOVD $742, R12 B callbackasm1(SB) MOVD $743, R12 B callbackasm1(SB) MOVD $744, R12 B callbackasm1(SB) MOVD $745, R12 B callbackasm1(SB) MOVD $746, R12 B callbackasm1(SB) MOVD $747, R12 B callbackasm1(SB) MOVD $748, R12 B callbackasm1(SB) MOVD $749, R12 B callbackasm1(SB) MOVD $750, R12 B callbackasm1(SB) MOVD $751, R12 B callbackasm1(SB) MOVD $752, R12 B callbackasm1(SB) MOVD $753, R12 B callbackasm1(SB) MOVD $754, R12 B callbackasm1(SB) MOVD $755, R12 B callbackasm1(SB) MOVD $756, R12 B callbackasm1(SB) MOVD $757, R12 B callbackasm1(SB) MOVD $758, R12 B callbackasm1(SB) MOVD $759, R12 B callbackasm1(SB) MOVD $760, R12 B callbackasm1(SB) MOVD $761, R12 B callbackasm1(SB) MOVD $762, R12 B callbackasm1(SB) MOVD $763, R12 B callbackasm1(SB) MOVD $764, R12 B callbackasm1(SB) MOVD $765, R12 B callbackasm1(SB) MOVD $766, R12 B callbackasm1(SB) MOVD $767, R12 B callbackasm1(SB) MOVD $768, R12 B callbackasm1(SB) MOVD $769, R12 B callbackasm1(SB) MOVD $770, R12 B callbackasm1(SB) MOVD $771, R12 B callbackasm1(SB) MOVD $772, R12 B callbackasm1(SB) MOVD $773, R12 B callbackasm1(SB) MOVD $774, R12 B callbackasm1(SB) MOVD $775, R12 B callbackasm1(SB) MOVD $776, R12 B callbackasm1(SB) MOVD $777, R12 B callbackasm1(SB) MOVD $778, R12 B callbackasm1(SB) MOVD $779, R12 B callbackasm1(SB) MOVD $780, R12 B callbackasm1(SB) MOVD $781, R12 B callbackasm1(SB) MOVD $782, R12 B callbackasm1(SB) MOVD $783, R12 B callbackasm1(SB) MOVD $784, R12 B callbackasm1(SB) MOVD $785, R12 B callbackasm1(SB) MOVD $786, R12 B callbackasm1(SB) MOVD $787, R12 B callbackasm1(SB) MOVD $788, R12 B callbackasm1(SB) MOVD $789, R12 B callbackasm1(SB) MOVD $790, R12 B callbackasm1(SB) MOVD $791, R12 B callbackasm1(SB) MOVD $792, R12 B callbackasm1(SB) MOVD $793, R12 B callbackasm1(SB) MOVD $794, R12 B callbackasm1(SB) MOVD $795, R12 B callbackasm1(SB) MOVD $796, R12 B callbackasm1(SB) MOVD $797, R12 B callbackasm1(SB) MOVD $798, R12 B callbackasm1(SB) MOVD $799, R12 B callbackasm1(SB) MOVD $800, R12 B callbackasm1(SB) MOVD $801, R12 B callbackasm1(SB) MOVD $802, R12 B callbackasm1(SB) MOVD $803, R12 B callbackasm1(SB) MOVD $804, R12 B callbackasm1(SB) MOVD $805, R12 B callbackasm1(SB) MOVD $806, R12 B callbackasm1(SB) MOVD $807, R12 B callbackasm1(SB) MOVD $808, R12 B callbackasm1(SB) MOVD $809, R12 B callbackasm1(SB) MOVD $810, R12 B callbackasm1(SB) MOVD $811, R12 B callbackasm1(SB) MOVD $812, R12 B callbackasm1(SB) MOVD $813, R12 B callbackasm1(SB) MOVD $814, R12 B callbackasm1(SB) MOVD $815, R12 B callbackasm1(SB) MOVD $816, R12 B callbackasm1(SB) MOVD $817, R12 B callbackasm1(SB) MOVD $818, R12 B callbackasm1(SB) MOVD $819, R12 B callbackasm1(SB) MOVD $820, R12 B callbackasm1(SB) MOVD $821, R12 B callbackasm1(SB) MOVD $822, R12 B callbackasm1(SB) MOVD $823, R12 B callbackasm1(SB) MOVD $824, R12 B callbackasm1(SB) MOVD $825, R12 B callbackasm1(SB) MOVD $826, R12 B callbackasm1(SB) MOVD $827, R12 B callbackasm1(SB) MOVD $828, R12 B callbackasm1(SB) MOVD $829, R12 B callbackasm1(SB) MOVD $830, R12 B callbackasm1(SB) MOVD $831, R12 B callbackasm1(SB) MOVD $832, R12 B callbackasm1(SB) MOVD $833, R12 B callbackasm1(SB) MOVD $834, R12 B callbackasm1(SB) MOVD $835, R12 B callbackasm1(SB) MOVD $836, R12 B callbackasm1(SB) MOVD $837, R12 B callbackasm1(SB) MOVD $838, R12 B callbackasm1(SB) MOVD $839, R12 B callbackasm1(SB) MOVD $840, R12 B callbackasm1(SB) MOVD $841, R12 B callbackasm1(SB) MOVD $842, R12 B callbackasm1(SB) MOVD $843, R12 B callbackasm1(SB) MOVD $844, R12 B callbackasm1(SB) MOVD $845, R12 B callbackasm1(SB) MOVD $846, R12 B callbackasm1(SB) MOVD $847, R12 B callbackasm1(SB) MOVD $848, R12 B callbackasm1(SB) MOVD $849, R12 B callbackasm1(SB) MOVD $850, R12 B callbackasm1(SB) MOVD $851, R12 B callbackasm1(SB) MOVD $852, R12 B callbackasm1(SB) MOVD $853, R12 B callbackasm1(SB) MOVD $854, R12 B callbackasm1(SB) MOVD $855, R12 B callbackasm1(SB) MOVD $856, R12 B callbackasm1(SB) MOVD $857, R12 B callbackasm1(SB) MOVD $858, R12 B callbackasm1(SB) MOVD $859, R12 B callbackasm1(SB) MOVD $860, R12 B callbackasm1(SB) MOVD $861, R12 B callbackasm1(SB) MOVD $862, R12 B callbackasm1(SB) MOVD $863, R12 B callbackasm1(SB) MOVD $864, R12 B callbackasm1(SB) MOVD $865, R12 B callbackasm1(SB) MOVD $866, R12 B callbackasm1(SB) MOVD $867, R12 B callbackasm1(SB) MOVD $868, R12 B callbackasm1(SB) MOVD $869, R12 B callbackasm1(SB) MOVD $870, R12 B callbackasm1(SB) MOVD $871, R12 B callbackasm1(SB) MOVD $872, R12 B callbackasm1(SB) MOVD $873, R12 B callbackasm1(SB) MOVD $874, R12 B callbackasm1(SB) MOVD $875, R12 B callbackasm1(SB) MOVD $876, R12 B callbackasm1(SB) MOVD $877, R12 B callbackasm1(SB) MOVD $878, R12 B callbackasm1(SB) MOVD $879, R12 B callbackasm1(SB) MOVD $880, R12 B callbackasm1(SB) MOVD $881, R12 B callbackasm1(SB) MOVD $882, R12 B callbackasm1(SB) MOVD $883, R12 B callbackasm1(SB) MOVD $884, R12 B callbackasm1(SB) MOVD $885, R12 B callbackasm1(SB) MOVD $886, R12 B callbackasm1(SB) MOVD $887, R12 B callbackasm1(SB) MOVD $888, R12 B callbackasm1(SB) MOVD $889, R12 B callbackasm1(SB) MOVD $890, R12 B callbackasm1(SB) MOVD $891, R12 B callbackasm1(SB) MOVD $892, R12 B callbackasm1(SB) MOVD $893, R12 B callbackasm1(SB) MOVD $894, R12 B callbackasm1(SB) MOVD $895, R12 B callbackasm1(SB) MOVD $896, R12 B callbackasm1(SB) MOVD $897, R12 B callbackasm1(SB) MOVD $898, R12 B callbackasm1(SB) MOVD $899, R12 B callbackasm1(SB) MOVD $900, R12 B callbackasm1(SB) MOVD $901, R12 B callbackasm1(SB) MOVD $902, R12 B callbackasm1(SB) MOVD $903, R12 B callbackasm1(SB) MOVD $904, R12 B callbackasm1(SB) MOVD $905, R12 B callbackasm1(SB) MOVD $906, R12 B callbackasm1(SB) MOVD $907, R12 B callbackasm1(SB) MOVD $908, R12 B callbackasm1(SB) MOVD $909, R12 B callbackasm1(SB) MOVD $910, R12 B callbackasm1(SB) MOVD $911, R12 B callbackasm1(SB) MOVD $912, R12 B callbackasm1(SB) MOVD $913, R12 B callbackasm1(SB) MOVD $914, R12 B callbackasm1(SB) MOVD $915, R12 B callbackasm1(SB) MOVD $916, R12 B callbackasm1(SB) MOVD $917, R12 B callbackasm1(SB) MOVD $918, R12 B callbackasm1(SB) MOVD $919, R12 B callbackasm1(SB) MOVD $920, R12 B callbackasm1(SB) MOVD $921, R12 B callbackasm1(SB) MOVD $922, R12 B callbackasm1(SB) MOVD $923, R12 B callbackasm1(SB) MOVD $924, R12 B callbackasm1(SB) MOVD $925, R12 B callbackasm1(SB) MOVD $926, R12 B callbackasm1(SB) MOVD $927, R12 B callbackasm1(SB) MOVD $928, R12 B callbackasm1(SB) MOVD $929, R12 B callbackasm1(SB) MOVD $930, R12 B callbackasm1(SB) MOVD $931, R12 B callbackasm1(SB) MOVD $932, R12 B callbackasm1(SB) MOVD $933, R12 B callbackasm1(SB) MOVD $934, R12 B callbackasm1(SB) MOVD $935, R12 B callbackasm1(SB) MOVD $936, R12 B callbackasm1(SB) MOVD $937, R12 B callbackasm1(SB) MOVD $938, R12 B callbackasm1(SB) MOVD $939, R12 B callbackasm1(SB) MOVD $940, R12 B callbackasm1(SB) MOVD $941, R12 B callbackasm1(SB) MOVD $942, R12 B callbackasm1(SB) MOVD $943, R12 B callbackasm1(SB) MOVD $944, R12 B callbackasm1(SB) MOVD $945, R12 B callbackasm1(SB) MOVD $946, R12 B callbackasm1(SB) MOVD $947, R12 B callbackasm1(SB) MOVD $948, R12 B callbackasm1(SB) MOVD $949, R12 B callbackasm1(SB) MOVD $950, R12 B callbackasm1(SB) MOVD $951, R12 B callbackasm1(SB) MOVD $952, R12 B callbackasm1(SB) MOVD $953, R12 B callbackasm1(SB) MOVD $954, R12 B callbackasm1(SB) MOVD $955, R12 B callbackasm1(SB) MOVD $956, R12 B callbackasm1(SB) MOVD $957, R12 B callbackasm1(SB) MOVD $958, R12 B callbackasm1(SB) MOVD $959, R12 B callbackasm1(SB) MOVD $960, R12 B callbackasm1(SB) MOVD $961, R12 B callbackasm1(SB) MOVD $962, R12 B callbackasm1(SB) MOVD $963, R12 B callbackasm1(SB) MOVD $964, R12 B callbackasm1(SB) MOVD $965, R12 B callbackasm1(SB) MOVD $966, R12 B callbackasm1(SB) MOVD $967, R12 B callbackasm1(SB) MOVD $968, R12 B callbackasm1(SB) MOVD $969, R12 B callbackasm1(SB) MOVD $970, R12 B callbackasm1(SB) MOVD $971, R12 B callbackasm1(SB) MOVD $972, R12 B callbackasm1(SB) MOVD $973, R12 B callbackasm1(SB) MOVD $974, R12 B callbackasm1(SB) MOVD $975, R12 B callbackasm1(SB) MOVD $976, R12 B callbackasm1(SB) MOVD $977, R12 B callbackasm1(SB) MOVD $978, R12 B callbackasm1(SB) MOVD $979, R12 B callbackasm1(SB) MOVD $980, R12 B callbackasm1(SB) MOVD $981, R12 B callbackasm1(SB) MOVD $982, R12 B callbackasm1(SB) MOVD $983, R12 B callbackasm1(SB) MOVD $984, R12 B callbackasm1(SB) MOVD $985, R12 B callbackasm1(SB) MOVD $986, R12 B callbackasm1(SB) MOVD $987, R12 B callbackasm1(SB) MOVD $988, R12 B callbackasm1(SB) MOVD $989, R12 B callbackasm1(SB) MOVD $990, R12 B callbackasm1(SB) MOVD $991, R12 B callbackasm1(SB) MOVD $992, R12 B callbackasm1(SB) MOVD $993, R12 B callbackasm1(SB) MOVD $994, R12 B callbackasm1(SB) MOVD $995, R12 B callbackasm1(SB) MOVD $996, R12 B callbackasm1(SB) MOVD $997, R12 B callbackasm1(SB) MOVD $998, R12 B callbackasm1(SB) MOVD $999, R12 B callbackasm1(SB) MOVD $1000, R12 B callbackasm1(SB) MOVD $1001, R12 B callbackasm1(SB) MOVD $1002, R12 B callbackasm1(SB) MOVD $1003, R12 B callbackasm1(SB) MOVD $1004, R12 B callbackasm1(SB) MOVD $1005, R12 B callbackasm1(SB) MOVD $1006, R12 B callbackasm1(SB) MOVD $1007, R12 B callbackasm1(SB) MOVD $1008, R12 B callbackasm1(SB) MOVD $1009, R12 B callbackasm1(SB) MOVD $1010, R12 B callbackasm1(SB) MOVD $1011, R12 B callbackasm1(SB) MOVD $1012, R12 B callbackasm1(SB) MOVD $1013, R12 B callbackasm1(SB) MOVD $1014, R12 B callbackasm1(SB) MOVD $1015, R12 B callbackasm1(SB) MOVD $1016, R12 B callbackasm1(SB) MOVD $1017, R12 B callbackasm1(SB) MOVD $1018, R12 B callbackasm1(SB) MOVD $1019, R12 B callbackasm1(SB) MOVD $1020, R12 B callbackasm1(SB) MOVD $1021, R12 B callbackasm1(SB) MOVD $1022, R12 B callbackasm1(SB) MOVD $1023, R12 B callbackasm1(SB) MOVD $1024, R12 B callbackasm1(SB) MOVD $1025, R12 B callbackasm1(SB) MOVD $1026, R12 B callbackasm1(SB) MOVD $1027, R12 B callbackasm1(SB) MOVD $1028, R12 B callbackasm1(SB) MOVD $1029, R12 B callbackasm1(SB) MOVD $1030, R12 B callbackasm1(SB) MOVD $1031, R12 B callbackasm1(SB) MOVD $1032, R12 B callbackasm1(SB) MOVD $1033, R12 B callbackasm1(SB) MOVD $1034, R12 B callbackasm1(SB) MOVD $1035, R12 B callbackasm1(SB) MOVD $1036, R12 B callbackasm1(SB) MOVD $1037, R12 B callbackasm1(SB) MOVD $1038, R12 B callbackasm1(SB) MOVD $1039, R12 B callbackasm1(SB) MOVD $1040, R12 B callbackasm1(SB) MOVD $1041, R12 B callbackasm1(SB) MOVD $1042, R12 B callbackasm1(SB) MOVD $1043, R12 B callbackasm1(SB) MOVD $1044, R12 B callbackasm1(SB) MOVD $1045, R12 B callbackasm1(SB) MOVD $1046, R12 B callbackasm1(SB) MOVD $1047, R12 B callbackasm1(SB) MOVD $1048, R12 B callbackasm1(SB) MOVD $1049, R12 B callbackasm1(SB) MOVD $1050, R12 B callbackasm1(SB) MOVD $1051, R12 B callbackasm1(SB) MOVD $1052, R12 B callbackasm1(SB) MOVD $1053, R12 B callbackasm1(SB) MOVD $1054, R12 B callbackasm1(SB) MOVD $1055, R12 B callbackasm1(SB) MOVD $1056, R12 B callbackasm1(SB) MOVD $1057, R12 B callbackasm1(SB) MOVD $1058, R12 B callbackasm1(SB) MOVD $1059, R12 B callbackasm1(SB) MOVD $1060, R12 B callbackasm1(SB) MOVD $1061, R12 B callbackasm1(SB) MOVD $1062, R12 B callbackasm1(SB) MOVD $1063, R12 B callbackasm1(SB) MOVD $1064, R12 B callbackasm1(SB) MOVD $1065, R12 B callbackasm1(SB) MOVD $1066, R12 B callbackasm1(SB) MOVD $1067, R12 B callbackasm1(SB) MOVD $1068, R12 B callbackasm1(SB) MOVD $1069, R12 B callbackasm1(SB) MOVD $1070, R12 B callbackasm1(SB) MOVD $1071, R12 B callbackasm1(SB) MOVD $1072, R12 B callbackasm1(SB) MOVD $1073, R12 B callbackasm1(SB) MOVD $1074, R12 B callbackasm1(SB) MOVD $1075, R12 B callbackasm1(SB) MOVD $1076, R12 B callbackasm1(SB) MOVD $1077, R12 B callbackasm1(SB) MOVD $1078, R12 B callbackasm1(SB) MOVD $1079, R12 B callbackasm1(SB) MOVD $1080, R12 B callbackasm1(SB) MOVD $1081, R12 B callbackasm1(SB) MOVD $1082, R12 B callbackasm1(SB) MOVD $1083, R12 B callbackasm1(SB) MOVD $1084, R12 B callbackasm1(SB) MOVD $1085, R12 B callbackasm1(SB) MOVD $1086, R12 B callbackasm1(SB) MOVD $1087, R12 B callbackasm1(SB) MOVD $1088, R12 B callbackasm1(SB) MOVD $1089, R12 B callbackasm1(SB) MOVD $1090, R12 B callbackasm1(SB) MOVD $1091, R12 B callbackasm1(SB) MOVD $1092, R12 B callbackasm1(SB) MOVD $1093, R12 B callbackasm1(SB) MOVD $1094, R12 B callbackasm1(SB) MOVD $1095, R12 B callbackasm1(SB) MOVD $1096, R12 B callbackasm1(SB) MOVD $1097, R12 B callbackasm1(SB) MOVD $1098, R12 B callbackasm1(SB) MOVD $1099, R12 B callbackasm1(SB) MOVD $1100, R12 B callbackasm1(SB) MOVD $1101, R12 B callbackasm1(SB) MOVD $1102, R12 B callbackasm1(SB) MOVD $1103, R12 B callbackasm1(SB) MOVD $1104, R12 B callbackasm1(SB) MOVD $1105, R12 B callbackasm1(SB) MOVD $1106, R12 B callbackasm1(SB) MOVD $1107, R12 B callbackasm1(SB) MOVD $1108, R12 B callbackasm1(SB) MOVD $1109, R12 B callbackasm1(SB) MOVD $1110, R12 B callbackasm1(SB) MOVD $1111, R12 B callbackasm1(SB) MOVD $1112, R12 B callbackasm1(SB) MOVD $1113, R12 B callbackasm1(SB) MOVD $1114, R12 B callbackasm1(SB) MOVD $1115, R12 B callbackasm1(SB) MOVD $1116, R12 B callbackasm1(SB) MOVD $1117, R12 B callbackasm1(SB) MOVD $1118, R12 B callbackasm1(SB) MOVD $1119, R12 B callbackasm1(SB) MOVD $1120, R12 B callbackasm1(SB) MOVD $1121, R12 B callbackasm1(SB) MOVD $1122, R12 B callbackasm1(SB) MOVD $1123, R12 B callbackasm1(SB) MOVD $1124, R12 B callbackasm1(SB) MOVD $1125, R12 B callbackasm1(SB) MOVD $1126, R12 B callbackasm1(SB) MOVD $1127, R12 B callbackasm1(SB) MOVD $1128, R12 B callbackasm1(SB) MOVD $1129, R12 B callbackasm1(SB) MOVD $1130, R12 B callbackasm1(SB) MOVD $1131, R12 B callbackasm1(SB) MOVD $1132, R12 B callbackasm1(SB) MOVD $1133, R12 B callbackasm1(SB) MOVD $1134, R12 B callbackasm1(SB) MOVD $1135, R12 B callbackasm1(SB) MOVD $1136, R12 B callbackasm1(SB) MOVD $1137, R12 B callbackasm1(SB) MOVD $1138, R12 B callbackasm1(SB) MOVD $1139, R12 B callbackasm1(SB) MOVD $1140, R12 B callbackasm1(SB) MOVD $1141, R12 B callbackasm1(SB) MOVD $1142, R12 B callbackasm1(SB) MOVD $1143, R12 B callbackasm1(SB) MOVD $1144, R12 B callbackasm1(SB) MOVD $1145, R12 B callbackasm1(SB) MOVD $1146, R12 B callbackasm1(SB) MOVD $1147, R12 B callbackasm1(SB) MOVD $1148, R12 B callbackasm1(SB) MOVD $1149, R12 B callbackasm1(SB) MOVD $1150, R12 B callbackasm1(SB) MOVD $1151, R12 B callbackasm1(SB) MOVD $1152, R12 B callbackasm1(SB) MOVD $1153, R12 B callbackasm1(SB) MOVD $1154, R12 B callbackasm1(SB) MOVD $1155, R12 B callbackasm1(SB) MOVD $1156, R12 B callbackasm1(SB) MOVD $1157, R12 B callbackasm1(SB) MOVD $1158, R12 B callbackasm1(SB) MOVD $1159, R12 B callbackasm1(SB) MOVD $1160, R12 B callbackasm1(SB) MOVD $1161, R12 B callbackasm1(SB) MOVD $1162, R12 B callbackasm1(SB) MOVD $1163, R12 B callbackasm1(SB) MOVD $1164, R12 B callbackasm1(SB) MOVD $1165, R12 B callbackasm1(SB) MOVD $1166, R12 B callbackasm1(SB) MOVD $1167, R12 B callbackasm1(SB) MOVD $1168, R12 B callbackasm1(SB) MOVD $1169, R12 B callbackasm1(SB) MOVD $1170, R12 B callbackasm1(SB) MOVD $1171, R12 B callbackasm1(SB) MOVD $1172, R12 B callbackasm1(SB) MOVD $1173, R12 B callbackasm1(SB) MOVD $1174, R12 B callbackasm1(SB) MOVD $1175, R12 B callbackasm1(SB) MOVD $1176, R12 B callbackasm1(SB) MOVD $1177, R12 B callbackasm1(SB) MOVD $1178, R12 B callbackasm1(SB) MOVD $1179, R12 B callbackasm1(SB) MOVD $1180, R12 B callbackasm1(SB) MOVD $1181, R12 B callbackasm1(SB) MOVD $1182, R12 B callbackasm1(SB) MOVD $1183, R12 B callbackasm1(SB) MOVD $1184, R12 B callbackasm1(SB) MOVD $1185, R12 B callbackasm1(SB) MOVD $1186, R12 B callbackasm1(SB) MOVD $1187, R12 B callbackasm1(SB) MOVD $1188, R12 B callbackasm1(SB) MOVD $1189, R12 B callbackasm1(SB) MOVD $1190, R12 B callbackasm1(SB) MOVD $1191, R12 B callbackasm1(SB) MOVD $1192, R12 B callbackasm1(SB) MOVD $1193, R12 B callbackasm1(SB) MOVD $1194, R12 B callbackasm1(SB) MOVD $1195, R12 B callbackasm1(SB) MOVD $1196, R12 B callbackasm1(SB) MOVD $1197, R12 B callbackasm1(SB) MOVD $1198, R12 B callbackasm1(SB) MOVD $1199, R12 B callbackasm1(SB) MOVD $1200, R12 B callbackasm1(SB) MOVD $1201, R12 B callbackasm1(SB) MOVD $1202, R12 B callbackasm1(SB) MOVD $1203, R12 B callbackasm1(SB) MOVD $1204, R12 B callbackasm1(SB) MOVD $1205, R12 B callbackasm1(SB) MOVD $1206, R12 B callbackasm1(SB) MOVD $1207, R12 B callbackasm1(SB) MOVD $1208, R12 B callbackasm1(SB) MOVD $1209, R12 B callbackasm1(SB) MOVD $1210, R12 B callbackasm1(SB) MOVD $1211, R12 B callbackasm1(SB) MOVD $1212, R12 B callbackasm1(SB) MOVD $1213, R12 B callbackasm1(SB) MOVD $1214, R12 B callbackasm1(SB) MOVD $1215, R12 B callbackasm1(SB) MOVD $1216, R12 B callbackasm1(SB) MOVD $1217, R12 B callbackasm1(SB) MOVD $1218, R12 B callbackasm1(SB) MOVD $1219, R12 B callbackasm1(SB) MOVD $1220, R12 B callbackasm1(SB) MOVD $1221, R12 B callbackasm1(SB) MOVD $1222, R12 B callbackasm1(SB) MOVD $1223, R12 B callbackasm1(SB) MOVD $1224, R12 B callbackasm1(SB) MOVD $1225, R12 B callbackasm1(SB) MOVD $1226, R12 B callbackasm1(SB) MOVD $1227, R12 B callbackasm1(SB) MOVD $1228, R12 B callbackasm1(SB) MOVD $1229, R12 B callbackasm1(SB) MOVD $1230, R12 B callbackasm1(SB) MOVD $1231, R12 B callbackasm1(SB) MOVD $1232, R12 B callbackasm1(SB) MOVD $1233, R12 B callbackasm1(SB) MOVD $1234, R12 B callbackasm1(SB) MOVD $1235, R12 B callbackasm1(SB) MOVD $1236, R12 B callbackasm1(SB) MOVD $1237, R12 B callbackasm1(SB) MOVD $1238, R12 B callbackasm1(SB) MOVD $1239, R12 B callbackasm1(SB) MOVD $1240, R12 B callbackasm1(SB) MOVD $1241, R12 B callbackasm1(SB) MOVD $1242, R12 B callbackasm1(SB) MOVD $1243, R12 B callbackasm1(SB) MOVD $1244, R12 B callbackasm1(SB) MOVD $1245, R12 B callbackasm1(SB) MOVD $1246, R12 B callbackasm1(SB) MOVD $1247, R12 B callbackasm1(SB) MOVD $1248, R12 B callbackasm1(SB) MOVD $1249, R12 B callbackasm1(SB) MOVD $1250, R12 B callbackasm1(SB) MOVD $1251, R12 B callbackasm1(SB) MOVD $1252, R12 B callbackasm1(SB) MOVD $1253, R12 B callbackasm1(SB) MOVD $1254, R12 B callbackasm1(SB) MOVD $1255, R12 B callbackasm1(SB) MOVD $1256, R12 B callbackasm1(SB) MOVD $1257, R12 B callbackasm1(SB) MOVD $1258, R12 B callbackasm1(SB) MOVD $1259, R12 B callbackasm1(SB) MOVD $1260, R12 B callbackasm1(SB) MOVD $1261, R12 B callbackasm1(SB) MOVD $1262, R12 B callbackasm1(SB) MOVD $1263, R12 B callbackasm1(SB) MOVD $1264, R12 B callbackasm1(SB) MOVD $1265, R12 B callbackasm1(SB) MOVD $1266, R12 B callbackasm1(SB) MOVD $1267, R12 B callbackasm1(SB) MOVD $1268, R12 B callbackasm1(SB) MOVD $1269, R12 B callbackasm1(SB) MOVD $1270, R12 B callbackasm1(SB) MOVD $1271, R12 B callbackasm1(SB) MOVD $1272, R12 B callbackasm1(SB) MOVD $1273, R12 B callbackasm1(SB) MOVD $1274, R12 B callbackasm1(SB) MOVD $1275, R12 B callbackasm1(SB) MOVD $1276, R12 B callbackasm1(SB) MOVD $1277, R12 B callbackasm1(SB) MOVD $1278, R12 B callbackasm1(SB) MOVD $1279, R12 B callbackasm1(SB) MOVD $1280, R12 B callbackasm1(SB) MOVD $1281, R12 B callbackasm1(SB) MOVD $1282, R12 B callbackasm1(SB) MOVD $1283, R12 B callbackasm1(SB) MOVD $1284, R12 B callbackasm1(SB) MOVD $1285, R12 B callbackasm1(SB) MOVD $1286, R12 B callbackasm1(SB) MOVD $1287, R12 B callbackasm1(SB) MOVD $1288, R12 B callbackasm1(SB) MOVD $1289, R12 B callbackasm1(SB) MOVD $1290, R12 B callbackasm1(SB) MOVD $1291, R12 B callbackasm1(SB) MOVD $1292, R12 B callbackasm1(SB) MOVD $1293, R12 B callbackasm1(SB) MOVD $1294, R12 B callbackasm1(SB) MOVD $1295, R12 B callbackasm1(SB) MOVD $1296, R12 B callbackasm1(SB) MOVD $1297, R12 B callbackasm1(SB) MOVD $1298, R12 B callbackasm1(SB) MOVD $1299, R12 B callbackasm1(SB) MOVD $1300, R12 B callbackasm1(SB) MOVD $1301, R12 B callbackasm1(SB) MOVD $1302, R12 B callbackasm1(SB) MOVD $1303, R12 B callbackasm1(SB) MOVD $1304, R12 B callbackasm1(SB) MOVD $1305, R12 B callbackasm1(SB) MOVD $1306, R12 B callbackasm1(SB) MOVD $1307, R12 B callbackasm1(SB) MOVD $1308, R12 B callbackasm1(SB) MOVD $1309, R12 B callbackasm1(SB) MOVD $1310, R12 B callbackasm1(SB) MOVD $1311, R12 B callbackasm1(SB) MOVD $1312, R12 B callbackasm1(SB) MOVD $1313, R12 B callbackasm1(SB) MOVD $1314, R12 B callbackasm1(SB) MOVD $1315, R12 B callbackasm1(SB) MOVD $1316, R12 B callbackasm1(SB) MOVD $1317, R12 B callbackasm1(SB) MOVD $1318, R12 B callbackasm1(SB) MOVD $1319, R12 B callbackasm1(SB) MOVD $1320, R12 B callbackasm1(SB) MOVD $1321, R12 B callbackasm1(SB) MOVD $1322, R12 B callbackasm1(SB) MOVD $1323, R12 B callbackasm1(SB) MOVD $1324, R12 B callbackasm1(SB) MOVD $1325, R12 B callbackasm1(SB) MOVD $1326, R12 B callbackasm1(SB) MOVD $1327, R12 B callbackasm1(SB) MOVD $1328, R12 B callbackasm1(SB) MOVD $1329, R12 B callbackasm1(SB) MOVD $1330, R12 B callbackasm1(SB) MOVD $1331, R12 B callbackasm1(SB) MOVD $1332, R12 B callbackasm1(SB) MOVD $1333, R12 B callbackasm1(SB) MOVD $1334, R12 B callbackasm1(SB) MOVD $1335, R12 B callbackasm1(SB) MOVD $1336, R12 B callbackasm1(SB) MOVD $1337, R12 B callbackasm1(SB) MOVD $1338, R12 B callbackasm1(SB) MOVD $1339, R12 B callbackasm1(SB) MOVD $1340, R12 B callbackasm1(SB) MOVD $1341, R12 B callbackasm1(SB) MOVD $1342, R12 B callbackasm1(SB) MOVD $1343, R12 B callbackasm1(SB) MOVD $1344, R12 B callbackasm1(SB) MOVD $1345, R12 B callbackasm1(SB) MOVD $1346, R12 B callbackasm1(SB) MOVD $1347, R12 B callbackasm1(SB) MOVD $1348, R12 B callbackasm1(SB) MOVD $1349, R12 B callbackasm1(SB) MOVD $1350, R12 B callbackasm1(SB) MOVD $1351, R12 B callbackasm1(SB) MOVD $1352, R12 B callbackasm1(SB) MOVD $1353, R12 B callbackasm1(SB) MOVD $1354, R12 B callbackasm1(SB) MOVD $1355, R12 B callbackasm1(SB) MOVD $1356, R12 B callbackasm1(SB) MOVD $1357, R12 B callbackasm1(SB) MOVD $1358, R12 B callbackasm1(SB) MOVD $1359, R12 B callbackasm1(SB) MOVD $1360, R12 B callbackasm1(SB) MOVD $1361, R12 B callbackasm1(SB) MOVD $1362, R12 B callbackasm1(SB) MOVD $1363, R12 B callbackasm1(SB) MOVD $1364, R12 B callbackasm1(SB) MOVD $1365, R12 B callbackasm1(SB) MOVD $1366, R12 B callbackasm1(SB) MOVD $1367, R12 B callbackasm1(SB) MOVD $1368, R12 B callbackasm1(SB) MOVD $1369, R12 B callbackasm1(SB) MOVD $1370, R12 B callbackasm1(SB) MOVD $1371, R12 B callbackasm1(SB) MOVD $1372, R12 B callbackasm1(SB) MOVD $1373, R12 B callbackasm1(SB) MOVD $1374, R12 B callbackasm1(SB) MOVD $1375, R12 B callbackasm1(SB) MOVD $1376, R12 B callbackasm1(SB) MOVD $1377, R12 B callbackasm1(SB) MOVD $1378, R12 B callbackasm1(SB) MOVD $1379, R12 B callbackasm1(SB) MOVD $1380, R12 B callbackasm1(SB) MOVD $1381, R12 B callbackasm1(SB) MOVD $1382, R12 B callbackasm1(SB) MOVD $1383, R12 B callbackasm1(SB) MOVD $1384, R12 B callbackasm1(SB) MOVD $1385, R12 B callbackasm1(SB) MOVD $1386, R12 B callbackasm1(SB) MOVD $1387, R12 B callbackasm1(SB) MOVD $1388, R12 B callbackasm1(SB) MOVD $1389, R12 B callbackasm1(SB) MOVD $1390, R12 B callbackasm1(SB) MOVD $1391, R12 B callbackasm1(SB) MOVD $1392, R12 B callbackasm1(SB) MOVD $1393, R12 B callbackasm1(SB) MOVD $1394, R12 B callbackasm1(SB) MOVD $1395, R12 B callbackasm1(SB) MOVD $1396, R12 B callbackasm1(SB) MOVD $1397, R12 B callbackasm1(SB) MOVD $1398, R12 B callbackasm1(SB) MOVD $1399, R12 B callbackasm1(SB) MOVD $1400, R12 B callbackasm1(SB) MOVD $1401, R12 B callbackasm1(SB) MOVD $1402, R12 B callbackasm1(SB) MOVD $1403, R12 B callbackasm1(SB) MOVD $1404, R12 B callbackasm1(SB) MOVD $1405, R12 B callbackasm1(SB) MOVD $1406, R12 B callbackasm1(SB) MOVD $1407, R12 B callbackasm1(SB) MOVD $1408, R12 B callbackasm1(SB) MOVD $1409, R12 B callbackasm1(SB) MOVD $1410, R12 B callbackasm1(SB) MOVD $1411, R12 B callbackasm1(SB) MOVD $1412, R12 B callbackasm1(SB) MOVD $1413, R12 B callbackasm1(SB) MOVD $1414, R12 B callbackasm1(SB) MOVD $1415, R12 B callbackasm1(SB) MOVD $1416, R12 B callbackasm1(SB) MOVD $1417, R12 B callbackasm1(SB) MOVD $1418, R12 B callbackasm1(SB) MOVD $1419, R12 B callbackasm1(SB) MOVD $1420, R12 B callbackasm1(SB) MOVD $1421, R12 B callbackasm1(SB) MOVD $1422, R12 B callbackasm1(SB) MOVD $1423, R12 B callbackasm1(SB) MOVD $1424, R12 B callbackasm1(SB) MOVD $1425, R12 B callbackasm1(SB) MOVD $1426, R12 B callbackasm1(SB) MOVD $1427, R12 B callbackasm1(SB) MOVD $1428, R12 B callbackasm1(SB) MOVD $1429, R12 B callbackasm1(SB) MOVD $1430, R12 B callbackasm1(SB) MOVD $1431, R12 B callbackasm1(SB) MOVD $1432, R12 B callbackasm1(SB) MOVD $1433, R12 B callbackasm1(SB) MOVD $1434, R12 B callbackasm1(SB) MOVD $1435, R12 B callbackasm1(SB) MOVD $1436, R12 B callbackasm1(SB) MOVD $1437, R12 B callbackasm1(SB) MOVD $1438, R12 B callbackasm1(SB) MOVD $1439, R12 B callbackasm1(SB) MOVD $1440, R12 B callbackasm1(SB) MOVD $1441, R12 B callbackasm1(SB) MOVD $1442, R12 B callbackasm1(SB) MOVD $1443, R12 B callbackasm1(SB) MOVD $1444, R12 B callbackasm1(SB) MOVD $1445, R12 B callbackasm1(SB) MOVD $1446, R12 B callbackasm1(SB) MOVD $1447, R12 B callbackasm1(SB) MOVD $1448, R12 B callbackasm1(SB) MOVD $1449, R12 B callbackasm1(SB) MOVD $1450, R12 B callbackasm1(SB) MOVD $1451, R12 B callbackasm1(SB) MOVD $1452, R12 B callbackasm1(SB) MOVD $1453, R12 B callbackasm1(SB) MOVD $1454, R12 B callbackasm1(SB) MOVD $1455, R12 B callbackasm1(SB) MOVD $1456, R12 B callbackasm1(SB) MOVD $1457, R12 B callbackasm1(SB) MOVD $1458, R12 B callbackasm1(SB) MOVD $1459, R12 B callbackasm1(SB) MOVD $1460, R12 B callbackasm1(SB) MOVD $1461, R12 B callbackasm1(SB) MOVD $1462, R12 B callbackasm1(SB) MOVD $1463, R12 B callbackasm1(SB) MOVD $1464, R12 B callbackasm1(SB) MOVD $1465, R12 B callbackasm1(SB) MOVD $1466, R12 B callbackasm1(SB) MOVD $1467, R12 B callbackasm1(SB) MOVD $1468, R12 B callbackasm1(SB) MOVD $1469, R12 B callbackasm1(SB) MOVD $1470, R12 B callbackasm1(SB) MOVD $1471, R12 B callbackasm1(SB) MOVD $1472, R12 B callbackasm1(SB) MOVD $1473, R12 B callbackasm1(SB) MOVD $1474, R12 B callbackasm1(SB) MOVD $1475, R12 B callbackasm1(SB) MOVD $1476, R12 B callbackasm1(SB) MOVD $1477, R12 B callbackasm1(SB) MOVD $1478, R12 B callbackasm1(SB) MOVD $1479, R12 B callbackasm1(SB) MOVD $1480, R12 B callbackasm1(SB) MOVD $1481, R12 B callbackasm1(SB) MOVD $1482, R12 B callbackasm1(SB) MOVD $1483, R12 B callbackasm1(SB) MOVD $1484, R12 B callbackasm1(SB) MOVD $1485, R12 B callbackasm1(SB) MOVD $1486, R12 B callbackasm1(SB) MOVD $1487, R12 B callbackasm1(SB) MOVD $1488, R12 B callbackasm1(SB) MOVD $1489, R12 B callbackasm1(SB) MOVD $1490, R12 B callbackasm1(SB) MOVD $1491, R12 B callbackasm1(SB) MOVD $1492, R12 B callbackasm1(SB) MOVD $1493, R12 B callbackasm1(SB) MOVD $1494, R12 B callbackasm1(SB) MOVD $1495, R12 B callbackasm1(SB) MOVD $1496, R12 B callbackasm1(SB) MOVD $1497, R12 B callbackasm1(SB) MOVD $1498, R12 B callbackasm1(SB) MOVD $1499, R12 B callbackasm1(SB) MOVD $1500, R12 B callbackasm1(SB) MOVD $1501, R12 B callbackasm1(SB) MOVD $1502, R12 B callbackasm1(SB) MOVD $1503, R12 B callbackasm1(SB) MOVD $1504, R12 B callbackasm1(SB) MOVD $1505, R12 B callbackasm1(SB) MOVD $1506, R12 B callbackasm1(SB) MOVD $1507, R12 B callbackasm1(SB) MOVD $1508, R12 B callbackasm1(SB) MOVD $1509, R12 B callbackasm1(SB) MOVD $1510, R12 B callbackasm1(SB) MOVD $1511, R12 B callbackasm1(SB) MOVD $1512, R12 B callbackasm1(SB) MOVD $1513, R12 B callbackasm1(SB) MOVD $1514, R12 B callbackasm1(SB) MOVD $1515, R12 B callbackasm1(SB) MOVD $1516, R12 B callbackasm1(SB) MOVD $1517, R12 B callbackasm1(SB) MOVD $1518, R12 B callbackasm1(SB) MOVD $1519, R12 B callbackasm1(SB) MOVD $1520, R12 B callbackasm1(SB) MOVD $1521, R12 B callbackasm1(SB) MOVD $1522, R12 B callbackasm1(SB) MOVD $1523, R12 B callbackasm1(SB) MOVD $1524, R12 B callbackasm1(SB) MOVD $1525, R12 B callbackasm1(SB) MOVD $1526, R12 B callbackasm1(SB) MOVD $1527, R12 B callbackasm1(SB) MOVD $1528, R12 B callbackasm1(SB) MOVD $1529, R12 B callbackasm1(SB) MOVD $1530, R12 B callbackasm1(SB) MOVD $1531, R12 B callbackasm1(SB) MOVD $1532, R12 B callbackasm1(SB) MOVD $1533, R12 B callbackasm1(SB) MOVD $1534, R12 B callbackasm1(SB) MOVD $1535, R12 B callbackasm1(SB) MOVD $1536, R12 B callbackasm1(SB) MOVD $1537, R12 B callbackasm1(SB) MOVD $1538, R12 B callbackasm1(SB) MOVD $1539, R12 B callbackasm1(SB) MOVD $1540, R12 B callbackasm1(SB) MOVD $1541, R12 B callbackasm1(SB) MOVD $1542, R12 B callbackasm1(SB) MOVD $1543, R12 B callbackasm1(SB) MOVD $1544, R12 B callbackasm1(SB) MOVD $1545, R12 B callbackasm1(SB) MOVD $1546, R12 B callbackasm1(SB) MOVD $1547, R12 B callbackasm1(SB) MOVD $1548, R12 B callbackasm1(SB) MOVD $1549, R12 B callbackasm1(SB) MOVD $1550, R12 B callbackasm1(SB) MOVD $1551, R12 B callbackasm1(SB) MOVD $1552, R12 B callbackasm1(SB) MOVD $1553, R12 B callbackasm1(SB) MOVD $1554, R12 B callbackasm1(SB) MOVD $1555, R12 B callbackasm1(SB) MOVD $1556, R12 B callbackasm1(SB) MOVD $1557, R12 B callbackasm1(SB) MOVD $1558, R12 B callbackasm1(SB) MOVD $1559, R12 B callbackasm1(SB) MOVD $1560, R12 B callbackasm1(SB) MOVD $1561, R12 B callbackasm1(SB) MOVD $1562, R12 B callbackasm1(SB) MOVD $1563, R12 B callbackasm1(SB) MOVD $1564, R12 B callbackasm1(SB) MOVD $1565, R12 B callbackasm1(SB) MOVD $1566, R12 B callbackasm1(SB) MOVD $1567, R12 B callbackasm1(SB) MOVD $1568, R12 B callbackasm1(SB) MOVD $1569, R12 B callbackasm1(SB) MOVD $1570, R12 B callbackasm1(SB) MOVD $1571, R12 B callbackasm1(SB) MOVD $1572, R12 B callbackasm1(SB) MOVD $1573, R12 B callbackasm1(SB) MOVD $1574, R12 B callbackasm1(SB) MOVD $1575, R12 B callbackasm1(SB) MOVD $1576, R12 B callbackasm1(SB) MOVD $1577, R12 B callbackasm1(SB) MOVD $1578, R12 B callbackasm1(SB) MOVD $1579, R12 B callbackasm1(SB) MOVD $1580, R12 B callbackasm1(SB) MOVD $1581, R12 B callbackasm1(SB) MOVD $1582, R12 B callbackasm1(SB) MOVD $1583, R12 B callbackasm1(SB) MOVD $1584, R12 B callbackasm1(SB) MOVD $1585, R12 B callbackasm1(SB) MOVD $1586, R12 B callbackasm1(SB) MOVD $1587, R12 B callbackasm1(SB) MOVD $1588, R12 B callbackasm1(SB) MOVD $1589, R12 B callbackasm1(SB) MOVD $1590, R12 B callbackasm1(SB) MOVD $1591, R12 B callbackasm1(SB) MOVD $1592, R12 B callbackasm1(SB) MOVD $1593, R12 B callbackasm1(SB) MOVD $1594, R12 B callbackasm1(SB) MOVD $1595, R12 B callbackasm1(SB) MOVD $1596, R12 B callbackasm1(SB) MOVD $1597, R12 B callbackasm1(SB) MOVD $1598, R12 B callbackasm1(SB) MOVD $1599, R12 B callbackasm1(SB) MOVD $1600, R12 B callbackasm1(SB) MOVD $1601, R12 B callbackasm1(SB) MOVD $1602, R12 B callbackasm1(SB) MOVD $1603, R12 B callbackasm1(SB) MOVD $1604, R12 B callbackasm1(SB) MOVD $1605, R12 B callbackasm1(SB) MOVD $1606, R12 B callbackasm1(SB) MOVD $1607, R12 B callbackasm1(SB) MOVD $1608, R12 B callbackasm1(SB) MOVD $1609, R12 B callbackasm1(SB) MOVD $1610, R12 B callbackasm1(SB) MOVD $1611, R12 B callbackasm1(SB) MOVD $1612, R12 B callbackasm1(SB) MOVD $1613, R12 B callbackasm1(SB) MOVD $1614, R12 B callbackasm1(SB) MOVD $1615, R12 B callbackasm1(SB) MOVD $1616, R12 B callbackasm1(SB) MOVD $1617, R12 B callbackasm1(SB) MOVD $1618, R12 B callbackasm1(SB) MOVD $1619, R12 B callbackasm1(SB) MOVD $1620, R12 B callbackasm1(SB) MOVD $1621, R12 B callbackasm1(SB) MOVD $1622, R12 B callbackasm1(SB) MOVD $1623, R12 B callbackasm1(SB) MOVD $1624, R12 B callbackasm1(SB) MOVD $1625, R12 B callbackasm1(SB) MOVD $1626, R12 B callbackasm1(SB) MOVD $1627, R12 B callbackasm1(SB) MOVD $1628, R12 B callbackasm1(SB) MOVD $1629, R12 B callbackasm1(SB) MOVD $1630, R12 B callbackasm1(SB) MOVD $1631, R12 B callbackasm1(SB) MOVD $1632, R12 B callbackasm1(SB) MOVD $1633, R12 B callbackasm1(SB) MOVD $1634, R12 B callbackasm1(SB) MOVD $1635, R12 B callbackasm1(SB) MOVD $1636, R12 B callbackasm1(SB) MOVD $1637, R12 B callbackasm1(SB) MOVD $1638, R12 B callbackasm1(SB) MOVD $1639, R12 B callbackasm1(SB) MOVD $1640, R12 B callbackasm1(SB) MOVD $1641, R12 B callbackasm1(SB) MOVD $1642, R12 B callbackasm1(SB) MOVD $1643, R12 B callbackasm1(SB) MOVD $1644, R12 B callbackasm1(SB) MOVD $1645, R12 B callbackasm1(SB) MOVD $1646, R12 B callbackasm1(SB) MOVD $1647, R12 B callbackasm1(SB) MOVD $1648, R12 B callbackasm1(SB) MOVD $1649, R12 B callbackasm1(SB) MOVD $1650, R12 B callbackasm1(SB) MOVD $1651, R12 B callbackasm1(SB) MOVD $1652, R12 B callbackasm1(SB) MOVD $1653, R12 B callbackasm1(SB) MOVD $1654, R12 B callbackasm1(SB) MOVD $1655, R12 B callbackasm1(SB) MOVD $1656, R12 B callbackasm1(SB) MOVD $1657, R12 B callbackasm1(SB) MOVD $1658, R12 B callbackasm1(SB) MOVD $1659, R12 B callbackasm1(SB) MOVD $1660, R12 B callbackasm1(SB) MOVD $1661, R12 B callbackasm1(SB) MOVD $1662, R12 B callbackasm1(SB) MOVD $1663, R12 B callbackasm1(SB) MOVD $1664, R12 B callbackasm1(SB) MOVD $1665, R12 B callbackasm1(SB) MOVD $1666, R12 B callbackasm1(SB) MOVD $1667, R12 B callbackasm1(SB) MOVD $1668, R12 B callbackasm1(SB) MOVD $1669, R12 B callbackasm1(SB) MOVD $1670, R12 B callbackasm1(SB) MOVD $1671, R12 B callbackasm1(SB) MOVD $1672, R12 B callbackasm1(SB) MOVD $1673, R12 B callbackasm1(SB) MOVD $1674, R12 B callbackasm1(SB) MOVD $1675, R12 B callbackasm1(SB) MOVD $1676, R12 B callbackasm1(SB) MOVD $1677, R12 B callbackasm1(SB) MOVD $1678, R12 B callbackasm1(SB) MOVD $1679, R12 B callbackasm1(SB) MOVD $1680, R12 B callbackasm1(SB) MOVD $1681, R12 B callbackasm1(SB) MOVD $1682, R12 B callbackasm1(SB) MOVD $1683, R12 B callbackasm1(SB) MOVD $1684, R12 B callbackasm1(SB) MOVD $1685, R12 B callbackasm1(SB) MOVD $1686, R12 B callbackasm1(SB) MOVD $1687, R12 B callbackasm1(SB) MOVD $1688, R12 B callbackasm1(SB) MOVD $1689, R12 B callbackasm1(SB) MOVD $1690, R12 B callbackasm1(SB) MOVD $1691, R12 B callbackasm1(SB) MOVD $1692, R12 B callbackasm1(SB) MOVD $1693, R12 B callbackasm1(SB) MOVD $1694, R12 B callbackasm1(SB) MOVD $1695, R12 B callbackasm1(SB) MOVD $1696, R12 B callbackasm1(SB) MOVD $1697, R12 B callbackasm1(SB) MOVD $1698, R12 B callbackasm1(SB) MOVD $1699, R12 B callbackasm1(SB) MOVD $1700, R12 B callbackasm1(SB) MOVD $1701, R12 B callbackasm1(SB) MOVD $1702, R12 B callbackasm1(SB) MOVD $1703, R12 B callbackasm1(SB) MOVD $1704, R12 B callbackasm1(SB) MOVD $1705, R12 B callbackasm1(SB) MOVD $1706, R12 B callbackasm1(SB) MOVD $1707, R12 B callbackasm1(SB) MOVD $1708, R12 B callbackasm1(SB) MOVD $1709, R12 B callbackasm1(SB) MOVD $1710, R12 B callbackasm1(SB) MOVD $1711, R12 B callbackasm1(SB) MOVD $1712, R12 B callbackasm1(SB) MOVD $1713, R12 B callbackasm1(SB) MOVD $1714, R12 B callbackasm1(SB) MOVD $1715, R12 B callbackasm1(SB) MOVD $1716, R12 B callbackasm1(SB) MOVD $1717, R12 B callbackasm1(SB) MOVD $1718, R12 B callbackasm1(SB) MOVD $1719, R12 B callbackasm1(SB) MOVD $1720, R12 B callbackasm1(SB) MOVD $1721, R12 B callbackasm1(SB) MOVD $1722, R12 B callbackasm1(SB) MOVD $1723, R12 B callbackasm1(SB) MOVD $1724, R12 B callbackasm1(SB) MOVD $1725, R12 B callbackasm1(SB) MOVD $1726, R12 B callbackasm1(SB) MOVD $1727, R12 B callbackasm1(SB) MOVD $1728, R12 B callbackasm1(SB) MOVD $1729, R12 B callbackasm1(SB) MOVD $1730, R12 B callbackasm1(SB) MOVD $1731, R12 B callbackasm1(SB) MOVD $1732, R12 B callbackasm1(SB) MOVD $1733, R12 B callbackasm1(SB) MOVD $1734, R12 B callbackasm1(SB) MOVD $1735, R12 B callbackasm1(SB) MOVD $1736, R12 B callbackasm1(SB) MOVD $1737, R12 B callbackasm1(SB) MOVD $1738, R12 B callbackasm1(SB) MOVD $1739, R12 B callbackasm1(SB) MOVD $1740, R12 B callbackasm1(SB) MOVD $1741, R12 B callbackasm1(SB) MOVD $1742, R12 B callbackasm1(SB) MOVD $1743, R12 B callbackasm1(SB) MOVD $1744, R12 B callbackasm1(SB) MOVD $1745, R12 B callbackasm1(SB) MOVD $1746, R12 B callbackasm1(SB) MOVD $1747, R12 B callbackasm1(SB) MOVD $1748, R12 B callbackasm1(SB) MOVD $1749, R12 B callbackasm1(SB) MOVD $1750, R12 B callbackasm1(SB) MOVD $1751, R12 B callbackasm1(SB) MOVD $1752, R12 B callbackasm1(SB) MOVD $1753, R12 B callbackasm1(SB) MOVD $1754, R12 B callbackasm1(SB) MOVD $1755, R12 B callbackasm1(SB) MOVD $1756, R12 B callbackasm1(SB) MOVD $1757, R12 B callbackasm1(SB) MOVD $1758, R12 B callbackasm1(SB) MOVD $1759, R12 B callbackasm1(SB) MOVD $1760, R12 B callbackasm1(SB) MOVD $1761, R12 B callbackasm1(SB) MOVD $1762, R12 B callbackasm1(SB) MOVD $1763, R12 B callbackasm1(SB) MOVD $1764, R12 B callbackasm1(SB) MOVD $1765, R12 B callbackasm1(SB) MOVD $1766, R12 B callbackasm1(SB) MOVD $1767, R12 B callbackasm1(SB) MOVD $1768, R12 B callbackasm1(SB) MOVD $1769, R12 B callbackasm1(SB) MOVD $1770, R12 B callbackasm1(SB) MOVD $1771, R12 B callbackasm1(SB) MOVD $1772, R12 B callbackasm1(SB) MOVD $1773, R12 B callbackasm1(SB) MOVD $1774, R12 B callbackasm1(SB) MOVD $1775, R12 B callbackasm1(SB) MOVD $1776, R12 B callbackasm1(SB) MOVD $1777, R12 B callbackasm1(SB) MOVD $1778, R12 B callbackasm1(SB) MOVD $1779, R12 B callbackasm1(SB) MOVD $1780, R12 B callbackasm1(SB) MOVD $1781, R12 B callbackasm1(SB) MOVD $1782, R12 B callbackasm1(SB) MOVD $1783, R12 B callbackasm1(SB) MOVD $1784, R12 B callbackasm1(SB) MOVD $1785, R12 B callbackasm1(SB) MOVD $1786, R12 B callbackasm1(SB) MOVD $1787, R12 B callbackasm1(SB) MOVD $1788, R12 B callbackasm1(SB) MOVD $1789, R12 B callbackasm1(SB) MOVD $1790, R12 B callbackasm1(SB) MOVD $1791, R12 B callbackasm1(SB) MOVD $1792, R12 B callbackasm1(SB) MOVD $1793, R12 B callbackasm1(SB) MOVD $1794, R12 B callbackasm1(SB) MOVD $1795, R12 B callbackasm1(SB) MOVD $1796, R12 B callbackasm1(SB) MOVD $1797, R12 B callbackasm1(SB) MOVD $1798, R12 B callbackasm1(SB) MOVD $1799, R12 B callbackasm1(SB) MOVD $1800, R12 B callbackasm1(SB) MOVD $1801, R12 B callbackasm1(SB) MOVD $1802, R12 B callbackasm1(SB) MOVD $1803, R12 B callbackasm1(SB) MOVD $1804, R12 B callbackasm1(SB) MOVD $1805, R12 B callbackasm1(SB) MOVD $1806, R12 B callbackasm1(SB) MOVD $1807, R12 B callbackasm1(SB) MOVD $1808, R12 B callbackasm1(SB) MOVD $1809, R12 B callbackasm1(SB) MOVD $1810, R12 B callbackasm1(SB) MOVD $1811, R12 B callbackasm1(SB) MOVD $1812, R12 B callbackasm1(SB) MOVD $1813, R12 B callbackasm1(SB) MOVD $1814, R12 B callbackasm1(SB) MOVD $1815, R12 B callbackasm1(SB) MOVD $1816, R12 B callbackasm1(SB) MOVD $1817, R12 B callbackasm1(SB) MOVD $1818, R12 B callbackasm1(SB) MOVD $1819, R12 B callbackasm1(SB) MOVD $1820, R12 B callbackasm1(SB) MOVD $1821, R12 B callbackasm1(SB) MOVD $1822, R12 B callbackasm1(SB) MOVD $1823, R12 B callbackasm1(SB) MOVD $1824, R12 B callbackasm1(SB) MOVD $1825, R12 B callbackasm1(SB) MOVD $1826, R12 B callbackasm1(SB) MOVD $1827, R12 B callbackasm1(SB) MOVD $1828, R12 B callbackasm1(SB) MOVD $1829, R12 B callbackasm1(SB) MOVD $1830, R12 B callbackasm1(SB) MOVD $1831, R12 B callbackasm1(SB) MOVD $1832, R12 B callbackasm1(SB) MOVD $1833, R12 B callbackasm1(SB) MOVD $1834, R12 B callbackasm1(SB) MOVD $1835, R12 B callbackasm1(SB) MOVD $1836, R12 B callbackasm1(SB) MOVD $1837, R12 B callbackasm1(SB) MOVD $1838, R12 B callbackasm1(SB) MOVD $1839, R12 B callbackasm1(SB) MOVD $1840, R12 B callbackasm1(SB) MOVD $1841, R12 B callbackasm1(SB) MOVD $1842, R12 B callbackasm1(SB) MOVD $1843, R12 B callbackasm1(SB) MOVD $1844, R12 B callbackasm1(SB) MOVD $1845, R12 B callbackasm1(SB) MOVD $1846, R12 B callbackasm1(SB) MOVD $1847, R12 B callbackasm1(SB) MOVD $1848, R12 B callbackasm1(SB) MOVD $1849, R12 B callbackasm1(SB) MOVD $1850, R12 B callbackasm1(SB) MOVD $1851, R12 B callbackasm1(SB) MOVD $1852, R12 B callbackasm1(SB) MOVD $1853, R12 B callbackasm1(SB) MOVD $1854, R12 B callbackasm1(SB) MOVD $1855, R12 B callbackasm1(SB) MOVD $1856, R12 B callbackasm1(SB) MOVD $1857, R12 B callbackasm1(SB) MOVD $1858, R12 B callbackasm1(SB) MOVD $1859, R12 B callbackasm1(SB) MOVD $1860, R12 B callbackasm1(SB) MOVD $1861, R12 B callbackasm1(SB) MOVD $1862, R12 B callbackasm1(SB) MOVD $1863, R12 B callbackasm1(SB) MOVD $1864, R12 B callbackasm1(SB) MOVD $1865, R12 B callbackasm1(SB) MOVD $1866, R12 B callbackasm1(SB) MOVD $1867, R12 B callbackasm1(SB) MOVD $1868, R12 B callbackasm1(SB) MOVD $1869, R12 B callbackasm1(SB) MOVD $1870, R12 B callbackasm1(SB) MOVD $1871, R12 B callbackasm1(SB) MOVD $1872, R12 B callbackasm1(SB) MOVD $1873, R12 B callbackasm1(SB) MOVD $1874, R12 B callbackasm1(SB) MOVD $1875, R12 B callbackasm1(SB) MOVD $1876, R12 B callbackasm1(SB) MOVD $1877, R12 B callbackasm1(SB) MOVD $1878, R12 B callbackasm1(SB) MOVD $1879, R12 B callbackasm1(SB) MOVD $1880, R12 B callbackasm1(SB) MOVD $1881, R12 B callbackasm1(SB) MOVD $1882, R12 B callbackasm1(SB) MOVD $1883, R12 B callbackasm1(SB) MOVD $1884, R12 B callbackasm1(SB) MOVD $1885, R12 B callbackasm1(SB) MOVD $1886, R12 B callbackasm1(SB) MOVD $1887, R12 B callbackasm1(SB) MOVD $1888, R12 B callbackasm1(SB) MOVD $1889, R12 B callbackasm1(SB) MOVD $1890, R12 B callbackasm1(SB) MOVD $1891, R12 B callbackasm1(SB) MOVD $1892, R12 B callbackasm1(SB) MOVD $1893, R12 B callbackasm1(SB) MOVD $1894, R12 B callbackasm1(SB) MOVD $1895, R12 B callbackasm1(SB) MOVD $1896, R12 B callbackasm1(SB) MOVD $1897, R12 B callbackasm1(SB) MOVD $1898, R12 B callbackasm1(SB) MOVD $1899, R12 B callbackasm1(SB) MOVD $1900, R12 B callbackasm1(SB) MOVD $1901, R12 B callbackasm1(SB) MOVD $1902, R12 B callbackasm1(SB) MOVD $1903, R12 B callbackasm1(SB) MOVD $1904, R12 B callbackasm1(SB) MOVD $1905, R12 B callbackasm1(SB) MOVD $1906, R12 B callbackasm1(SB) MOVD $1907, R12 B callbackasm1(SB) MOVD $1908, R12 B callbackasm1(SB) MOVD $1909, R12 B callbackasm1(SB) MOVD $1910, R12 B callbackasm1(SB) MOVD $1911, R12 B callbackasm1(SB) MOVD $1912, R12 B callbackasm1(SB) MOVD $1913, R12 B callbackasm1(SB) MOVD $1914, R12 B callbackasm1(SB) MOVD $1915, R12 B callbackasm1(SB) MOVD $1916, R12 B callbackasm1(SB) MOVD $1917, R12 B callbackasm1(SB) MOVD $1918, R12 B callbackasm1(SB) MOVD $1919, R12 B callbackasm1(SB) MOVD $1920, R12 B callbackasm1(SB) MOVD $1921, R12 B callbackasm1(SB) MOVD $1922, R12 B callbackasm1(SB) MOVD $1923, R12 B callbackasm1(SB) MOVD $1924, R12 B callbackasm1(SB) MOVD $1925, R12 B callbackasm1(SB) MOVD $1926, R12 B callbackasm1(SB) MOVD $1927, R12 B callbackasm1(SB) MOVD $1928, R12 B callbackasm1(SB) MOVD $1929, R12 B callbackasm1(SB) MOVD $1930, R12 B callbackasm1(SB) MOVD $1931, R12 B callbackasm1(SB) MOVD $1932, R12 B callbackasm1(SB) MOVD $1933, R12 B callbackasm1(SB) MOVD $1934, R12 B callbackasm1(SB) MOVD $1935, R12 B callbackasm1(SB) MOVD $1936, R12 B callbackasm1(SB) MOVD $1937, R12 B callbackasm1(SB) MOVD $1938, R12 B callbackasm1(SB) MOVD $1939, R12 B callbackasm1(SB) MOVD $1940, R12 B callbackasm1(SB) MOVD $1941, R12 B callbackasm1(SB) MOVD $1942, R12 B callbackasm1(SB) MOVD $1943, R12 B callbackasm1(SB) MOVD $1944, R12 B callbackasm1(SB) MOVD $1945, R12 B callbackasm1(SB) MOVD $1946, R12 B callbackasm1(SB) MOVD $1947, R12 B callbackasm1(SB) MOVD $1948, R12 B callbackasm1(SB) MOVD $1949, R12 B callbackasm1(SB) MOVD $1950, R12 B callbackasm1(SB) MOVD $1951, R12 B callbackasm1(SB) MOVD $1952, R12 B callbackasm1(SB) MOVD $1953, R12 B callbackasm1(SB) MOVD $1954, R12 B callbackasm1(SB) MOVD $1955, R12 B callbackasm1(SB) MOVD $1956, R12 B callbackasm1(SB) MOVD $1957, R12 B callbackasm1(SB) MOVD $1958, R12 B callbackasm1(SB) MOVD $1959, R12 B callbackasm1(SB) MOVD $1960, R12 B callbackasm1(SB) MOVD $1961, R12 B callbackasm1(SB) MOVD $1962, R12 B callbackasm1(SB) MOVD $1963, R12 B callbackasm1(SB) MOVD $1964, R12 B callbackasm1(SB) MOVD $1965, R12 B callbackasm1(SB) MOVD $1966, R12 B callbackasm1(SB) MOVD $1967, R12 B callbackasm1(SB) MOVD $1968, R12 B callbackasm1(SB) MOVD $1969, R12 B callbackasm1(SB) MOVD $1970, R12 B callbackasm1(SB) MOVD $1971, R12 B callbackasm1(SB) MOVD $1972, R12 B callbackasm1(SB) MOVD $1973, R12 B callbackasm1(SB) MOVD $1974, R12 B callbackasm1(SB) MOVD $1975, R12 B callbackasm1(SB) MOVD $1976, R12 B callbackasm1(SB) MOVD $1977, R12 B callbackasm1(SB) MOVD $1978, R12 B callbackasm1(SB) MOVD $1979, R12 B callbackasm1(SB) MOVD $1980, R12 B callbackasm1(SB) MOVD $1981, R12 B callbackasm1(SB) MOVD $1982, R12 B callbackasm1(SB) MOVD $1983, R12 B callbackasm1(SB) MOVD $1984, R12 B callbackasm1(SB) MOVD $1985, R12 B callbackasm1(SB) MOVD $1986, R12 B callbackasm1(SB) MOVD $1987, R12 B callbackasm1(SB) MOVD $1988, R12 B callbackasm1(SB) MOVD $1989, R12 B callbackasm1(SB) MOVD $1990, R12 B callbackasm1(SB) MOVD $1991, R12 B callbackasm1(SB) MOVD $1992, R12 B callbackasm1(SB) MOVD $1993, R12 B callbackasm1(SB) MOVD $1994, R12 B callbackasm1(SB) MOVD $1995, R12 B callbackasm1(SB) MOVD $1996, R12 B callbackasm1(SB) MOVD $1997, R12 B callbackasm1(SB) MOVD $1998, R12 B callbackasm1(SB) MOVD $1999, R12 B callbackasm1(SB) golang-github-ebitengine-purego-0.9.1/zcallback_loong64.s000066400000000000000000002273111512124053000233370ustar00rootroot00000000000000// Code generated by wincallback.go using 'go generate'. DO NOT EDIT. //go:build darwin || freebsd || linux || netbsd // External code calls into callbackasm at an offset corresponding // to the callback index. Callbackasm is a table of MOVV and JMP instructions. // The MOVV instruction loads R12 with the callback index, and the // JMP instruction branches to callbackasm1. // callbackasm1 takes the callback index from R12 and // indexes into an array that stores information about each callback. // It then calls the Go implementation for that callback. #include "textflag.h" TEXT callbackasm(SB),NOSPLIT|NOFRAME,$0 MOVV $0, R12 JMP callbackasm1(SB) MOVV $1, R12 JMP callbackasm1(SB) MOVV $2, R12 JMP callbackasm1(SB) MOVV $3, R12 JMP callbackasm1(SB) MOVV $4, R12 JMP callbackasm1(SB) MOVV $5, R12 JMP callbackasm1(SB) MOVV $6, R12 JMP callbackasm1(SB) MOVV $7, R12 JMP callbackasm1(SB) MOVV $8, R12 JMP callbackasm1(SB) MOVV $9, R12 JMP callbackasm1(SB) MOVV $10, R12 JMP callbackasm1(SB) MOVV $11, R12 JMP callbackasm1(SB) MOVV $12, R12 JMP callbackasm1(SB) MOVV $13, R12 JMP callbackasm1(SB) MOVV $14, R12 JMP callbackasm1(SB) MOVV $15, R12 JMP callbackasm1(SB) MOVV $16, R12 JMP callbackasm1(SB) MOVV $17, R12 JMP callbackasm1(SB) MOVV $18, R12 JMP callbackasm1(SB) MOVV $19, R12 JMP callbackasm1(SB) MOVV $20, R12 JMP callbackasm1(SB) MOVV $21, R12 JMP callbackasm1(SB) MOVV $22, R12 JMP callbackasm1(SB) MOVV $23, R12 JMP callbackasm1(SB) MOVV $24, R12 JMP callbackasm1(SB) MOVV $25, R12 JMP callbackasm1(SB) MOVV $26, R12 JMP callbackasm1(SB) MOVV $27, R12 JMP callbackasm1(SB) MOVV $28, R12 JMP callbackasm1(SB) MOVV $29, R12 JMP callbackasm1(SB) MOVV $30, R12 JMP callbackasm1(SB) MOVV $31, R12 JMP callbackasm1(SB) MOVV $32, R12 JMP callbackasm1(SB) MOVV $33, R12 JMP callbackasm1(SB) MOVV $34, R12 JMP callbackasm1(SB) MOVV $35, R12 JMP callbackasm1(SB) MOVV $36, R12 JMP callbackasm1(SB) MOVV $37, R12 JMP callbackasm1(SB) MOVV $38, R12 JMP callbackasm1(SB) MOVV $39, R12 JMP callbackasm1(SB) MOVV $40, R12 JMP callbackasm1(SB) MOVV $41, R12 JMP callbackasm1(SB) MOVV $42, R12 JMP callbackasm1(SB) MOVV $43, R12 JMP callbackasm1(SB) MOVV $44, R12 JMP callbackasm1(SB) MOVV $45, R12 JMP callbackasm1(SB) MOVV $46, R12 JMP callbackasm1(SB) MOVV $47, R12 JMP callbackasm1(SB) MOVV $48, R12 JMP callbackasm1(SB) MOVV $49, R12 JMP callbackasm1(SB) MOVV $50, R12 JMP callbackasm1(SB) MOVV $51, R12 JMP callbackasm1(SB) MOVV $52, R12 JMP callbackasm1(SB) MOVV $53, R12 JMP callbackasm1(SB) MOVV $54, R12 JMP callbackasm1(SB) MOVV $55, R12 JMP callbackasm1(SB) MOVV $56, R12 JMP callbackasm1(SB) MOVV $57, R12 JMP callbackasm1(SB) MOVV $58, R12 JMP callbackasm1(SB) MOVV $59, R12 JMP callbackasm1(SB) MOVV $60, R12 JMP callbackasm1(SB) MOVV $61, R12 JMP callbackasm1(SB) MOVV $62, R12 JMP callbackasm1(SB) MOVV $63, R12 JMP callbackasm1(SB) MOVV $64, R12 JMP callbackasm1(SB) MOVV $65, R12 JMP callbackasm1(SB) MOVV $66, R12 JMP callbackasm1(SB) MOVV $67, R12 JMP callbackasm1(SB) MOVV $68, R12 JMP callbackasm1(SB) MOVV $69, R12 JMP callbackasm1(SB) MOVV $70, R12 JMP callbackasm1(SB) MOVV $71, R12 JMP callbackasm1(SB) MOVV $72, R12 JMP callbackasm1(SB) MOVV $73, R12 JMP callbackasm1(SB) MOVV $74, R12 JMP callbackasm1(SB) MOVV $75, R12 JMP callbackasm1(SB) MOVV $76, R12 JMP callbackasm1(SB) MOVV $77, R12 JMP callbackasm1(SB) MOVV $78, R12 JMP callbackasm1(SB) MOVV $79, R12 JMP callbackasm1(SB) MOVV $80, R12 JMP callbackasm1(SB) MOVV $81, R12 JMP callbackasm1(SB) MOVV $82, R12 JMP callbackasm1(SB) MOVV $83, R12 JMP callbackasm1(SB) MOVV $84, R12 JMP callbackasm1(SB) MOVV $85, R12 JMP callbackasm1(SB) MOVV $86, R12 JMP callbackasm1(SB) MOVV $87, R12 JMP callbackasm1(SB) MOVV $88, R12 JMP callbackasm1(SB) MOVV $89, R12 JMP callbackasm1(SB) MOVV $90, R12 JMP callbackasm1(SB) MOVV $91, R12 JMP callbackasm1(SB) MOVV $92, R12 JMP callbackasm1(SB) MOVV $93, R12 JMP callbackasm1(SB) MOVV $94, R12 JMP callbackasm1(SB) MOVV $95, R12 JMP callbackasm1(SB) MOVV $96, R12 JMP callbackasm1(SB) MOVV $97, R12 JMP callbackasm1(SB) MOVV $98, R12 JMP callbackasm1(SB) MOVV $99, R12 JMP callbackasm1(SB) MOVV $100, R12 JMP callbackasm1(SB) MOVV $101, R12 JMP callbackasm1(SB) MOVV $102, R12 JMP callbackasm1(SB) MOVV $103, R12 JMP callbackasm1(SB) MOVV $104, R12 JMP callbackasm1(SB) MOVV $105, R12 JMP callbackasm1(SB) MOVV $106, R12 JMP callbackasm1(SB) MOVV $107, R12 JMP callbackasm1(SB) MOVV $108, R12 JMP callbackasm1(SB) MOVV $109, R12 JMP callbackasm1(SB) MOVV $110, R12 JMP callbackasm1(SB) MOVV $111, R12 JMP callbackasm1(SB) MOVV $112, R12 JMP callbackasm1(SB) MOVV $113, R12 JMP callbackasm1(SB) MOVV $114, R12 JMP callbackasm1(SB) MOVV $115, R12 JMP callbackasm1(SB) MOVV $116, R12 JMP callbackasm1(SB) MOVV $117, R12 JMP callbackasm1(SB) MOVV $118, R12 JMP callbackasm1(SB) MOVV $119, R12 JMP callbackasm1(SB) MOVV $120, R12 JMP callbackasm1(SB) MOVV $121, R12 JMP callbackasm1(SB) MOVV $122, R12 JMP callbackasm1(SB) MOVV $123, R12 JMP callbackasm1(SB) MOVV $124, R12 JMP callbackasm1(SB) MOVV $125, R12 JMP callbackasm1(SB) MOVV $126, R12 JMP callbackasm1(SB) MOVV $127, R12 JMP callbackasm1(SB) MOVV $128, R12 JMP callbackasm1(SB) MOVV $129, R12 JMP callbackasm1(SB) MOVV $130, R12 JMP callbackasm1(SB) MOVV $131, R12 JMP callbackasm1(SB) MOVV $132, R12 JMP callbackasm1(SB) MOVV $133, R12 JMP callbackasm1(SB) MOVV $134, R12 JMP callbackasm1(SB) MOVV $135, R12 JMP callbackasm1(SB) MOVV $136, R12 JMP callbackasm1(SB) MOVV $137, R12 JMP callbackasm1(SB) MOVV $138, R12 JMP callbackasm1(SB) MOVV $139, R12 JMP callbackasm1(SB) MOVV $140, R12 JMP callbackasm1(SB) MOVV $141, R12 JMP callbackasm1(SB) MOVV $142, R12 JMP callbackasm1(SB) MOVV $143, R12 JMP callbackasm1(SB) MOVV $144, R12 JMP callbackasm1(SB) MOVV $145, R12 JMP callbackasm1(SB) MOVV $146, R12 JMP callbackasm1(SB) MOVV $147, R12 JMP callbackasm1(SB) MOVV $148, R12 JMP callbackasm1(SB) MOVV $149, R12 JMP callbackasm1(SB) MOVV $150, R12 JMP callbackasm1(SB) MOVV $151, R12 JMP callbackasm1(SB) MOVV $152, R12 JMP callbackasm1(SB) MOVV $153, R12 JMP callbackasm1(SB) MOVV $154, R12 JMP callbackasm1(SB) MOVV $155, R12 JMP callbackasm1(SB) MOVV $156, R12 JMP callbackasm1(SB) MOVV $157, R12 JMP callbackasm1(SB) MOVV $158, R12 JMP callbackasm1(SB) MOVV $159, R12 JMP callbackasm1(SB) MOVV $160, R12 JMP callbackasm1(SB) MOVV $161, R12 JMP callbackasm1(SB) MOVV $162, R12 JMP callbackasm1(SB) MOVV $163, R12 JMP callbackasm1(SB) MOVV $164, R12 JMP callbackasm1(SB) MOVV $165, R12 JMP callbackasm1(SB) MOVV $166, R12 JMP callbackasm1(SB) MOVV $167, R12 JMP callbackasm1(SB) MOVV $168, R12 JMP callbackasm1(SB) MOVV $169, R12 JMP callbackasm1(SB) MOVV $170, R12 JMP callbackasm1(SB) MOVV $171, R12 JMP callbackasm1(SB) MOVV $172, R12 JMP callbackasm1(SB) MOVV $173, R12 JMP callbackasm1(SB) MOVV $174, R12 JMP callbackasm1(SB) MOVV $175, R12 JMP callbackasm1(SB) MOVV $176, R12 JMP callbackasm1(SB) MOVV $177, R12 JMP callbackasm1(SB) MOVV $178, R12 JMP callbackasm1(SB) MOVV $179, R12 JMP callbackasm1(SB) MOVV $180, R12 JMP callbackasm1(SB) MOVV $181, R12 JMP callbackasm1(SB) MOVV $182, R12 JMP callbackasm1(SB) MOVV $183, R12 JMP callbackasm1(SB) MOVV $184, R12 JMP callbackasm1(SB) MOVV $185, R12 JMP callbackasm1(SB) MOVV $186, R12 JMP callbackasm1(SB) MOVV $187, R12 JMP callbackasm1(SB) MOVV $188, R12 JMP callbackasm1(SB) MOVV $189, R12 JMP callbackasm1(SB) MOVV $190, R12 JMP callbackasm1(SB) MOVV $191, R12 JMP callbackasm1(SB) MOVV $192, R12 JMP callbackasm1(SB) MOVV $193, R12 JMP callbackasm1(SB) MOVV $194, R12 JMP callbackasm1(SB) MOVV $195, R12 JMP callbackasm1(SB) MOVV $196, R12 JMP callbackasm1(SB) MOVV $197, R12 JMP callbackasm1(SB) MOVV $198, R12 JMP callbackasm1(SB) MOVV $199, R12 JMP callbackasm1(SB) MOVV $200, R12 JMP callbackasm1(SB) MOVV $201, R12 JMP callbackasm1(SB) MOVV $202, R12 JMP callbackasm1(SB) MOVV $203, R12 JMP callbackasm1(SB) MOVV $204, R12 JMP callbackasm1(SB) MOVV $205, R12 JMP callbackasm1(SB) MOVV $206, R12 JMP callbackasm1(SB) MOVV $207, R12 JMP callbackasm1(SB) MOVV $208, R12 JMP callbackasm1(SB) MOVV $209, R12 JMP callbackasm1(SB) MOVV $210, R12 JMP callbackasm1(SB) MOVV $211, R12 JMP callbackasm1(SB) MOVV $212, R12 JMP callbackasm1(SB) MOVV $213, R12 JMP callbackasm1(SB) MOVV $214, R12 JMP callbackasm1(SB) MOVV $215, R12 JMP callbackasm1(SB) MOVV $216, R12 JMP callbackasm1(SB) MOVV $217, R12 JMP callbackasm1(SB) MOVV $218, R12 JMP callbackasm1(SB) MOVV $219, R12 JMP callbackasm1(SB) MOVV $220, R12 JMP callbackasm1(SB) MOVV $221, R12 JMP callbackasm1(SB) MOVV $222, R12 JMP callbackasm1(SB) MOVV $223, R12 JMP callbackasm1(SB) MOVV $224, R12 JMP callbackasm1(SB) MOVV $225, R12 JMP callbackasm1(SB) MOVV $226, R12 JMP callbackasm1(SB) MOVV $227, R12 JMP callbackasm1(SB) MOVV $228, R12 JMP callbackasm1(SB) MOVV $229, R12 JMP callbackasm1(SB) MOVV $230, R12 JMP callbackasm1(SB) MOVV $231, R12 JMP callbackasm1(SB) MOVV $232, R12 JMP callbackasm1(SB) MOVV $233, R12 JMP callbackasm1(SB) MOVV $234, R12 JMP callbackasm1(SB) MOVV $235, R12 JMP callbackasm1(SB) MOVV $236, R12 JMP callbackasm1(SB) MOVV $237, R12 JMP callbackasm1(SB) MOVV $238, R12 JMP callbackasm1(SB) MOVV $239, R12 JMP callbackasm1(SB) MOVV $240, R12 JMP callbackasm1(SB) MOVV $241, R12 JMP callbackasm1(SB) MOVV $242, R12 JMP callbackasm1(SB) MOVV $243, R12 JMP callbackasm1(SB) MOVV $244, R12 JMP callbackasm1(SB) MOVV $245, R12 JMP callbackasm1(SB) MOVV $246, R12 JMP callbackasm1(SB) MOVV $247, R12 JMP callbackasm1(SB) MOVV $248, R12 JMP callbackasm1(SB) MOVV $249, R12 JMP callbackasm1(SB) MOVV $250, R12 JMP callbackasm1(SB) MOVV $251, R12 JMP callbackasm1(SB) MOVV $252, R12 JMP callbackasm1(SB) MOVV $253, R12 JMP callbackasm1(SB) MOVV $254, R12 JMP callbackasm1(SB) MOVV $255, R12 JMP callbackasm1(SB) MOVV $256, R12 JMP callbackasm1(SB) MOVV $257, R12 JMP callbackasm1(SB) MOVV $258, R12 JMP callbackasm1(SB) MOVV $259, R12 JMP callbackasm1(SB) MOVV $260, R12 JMP callbackasm1(SB) MOVV $261, R12 JMP callbackasm1(SB) MOVV $262, R12 JMP callbackasm1(SB) MOVV $263, R12 JMP callbackasm1(SB) MOVV $264, R12 JMP callbackasm1(SB) MOVV $265, R12 JMP callbackasm1(SB) MOVV $266, R12 JMP callbackasm1(SB) MOVV $267, R12 JMP callbackasm1(SB) MOVV $268, R12 JMP callbackasm1(SB) MOVV $269, R12 JMP callbackasm1(SB) MOVV $270, R12 JMP callbackasm1(SB) MOVV $271, R12 JMP callbackasm1(SB) MOVV $272, R12 JMP callbackasm1(SB) MOVV $273, R12 JMP callbackasm1(SB) MOVV $274, R12 JMP callbackasm1(SB) MOVV $275, R12 JMP callbackasm1(SB) MOVV $276, R12 JMP callbackasm1(SB) MOVV $277, R12 JMP callbackasm1(SB) MOVV $278, R12 JMP callbackasm1(SB) MOVV $279, R12 JMP callbackasm1(SB) MOVV $280, R12 JMP callbackasm1(SB) MOVV $281, R12 JMP callbackasm1(SB) MOVV $282, R12 JMP callbackasm1(SB) MOVV $283, R12 JMP callbackasm1(SB) MOVV $284, R12 JMP callbackasm1(SB) MOVV $285, R12 JMP callbackasm1(SB) MOVV $286, R12 JMP callbackasm1(SB) MOVV $287, R12 JMP callbackasm1(SB) MOVV $288, R12 JMP callbackasm1(SB) MOVV $289, R12 JMP callbackasm1(SB) MOVV $290, R12 JMP callbackasm1(SB) MOVV $291, R12 JMP callbackasm1(SB) MOVV $292, R12 JMP callbackasm1(SB) MOVV $293, R12 JMP callbackasm1(SB) MOVV $294, R12 JMP callbackasm1(SB) MOVV $295, R12 JMP callbackasm1(SB) MOVV $296, R12 JMP callbackasm1(SB) MOVV $297, R12 JMP callbackasm1(SB) MOVV $298, R12 JMP callbackasm1(SB) MOVV $299, R12 JMP callbackasm1(SB) MOVV $300, R12 JMP callbackasm1(SB) MOVV $301, R12 JMP callbackasm1(SB) MOVV $302, R12 JMP callbackasm1(SB) MOVV $303, R12 JMP callbackasm1(SB) MOVV $304, R12 JMP callbackasm1(SB) MOVV $305, R12 JMP callbackasm1(SB) MOVV $306, R12 JMP callbackasm1(SB) MOVV $307, R12 JMP callbackasm1(SB) MOVV $308, R12 JMP callbackasm1(SB) MOVV $309, R12 JMP callbackasm1(SB) MOVV $310, R12 JMP callbackasm1(SB) MOVV $311, R12 JMP callbackasm1(SB) MOVV $312, R12 JMP callbackasm1(SB) MOVV $313, R12 JMP callbackasm1(SB) MOVV $314, R12 JMP callbackasm1(SB) MOVV $315, R12 JMP callbackasm1(SB) MOVV $316, R12 JMP callbackasm1(SB) MOVV $317, R12 JMP callbackasm1(SB) MOVV $318, R12 JMP callbackasm1(SB) MOVV $319, R12 JMP callbackasm1(SB) MOVV $320, R12 JMP callbackasm1(SB) MOVV $321, R12 JMP callbackasm1(SB) MOVV $322, R12 JMP callbackasm1(SB) MOVV $323, R12 JMP callbackasm1(SB) MOVV $324, R12 JMP callbackasm1(SB) MOVV $325, R12 JMP callbackasm1(SB) MOVV $326, R12 JMP callbackasm1(SB) MOVV $327, R12 JMP callbackasm1(SB) MOVV $328, R12 JMP callbackasm1(SB) MOVV $329, R12 JMP callbackasm1(SB) MOVV $330, R12 JMP callbackasm1(SB) MOVV $331, R12 JMP callbackasm1(SB) MOVV $332, R12 JMP callbackasm1(SB) MOVV $333, R12 JMP callbackasm1(SB) MOVV $334, R12 JMP callbackasm1(SB) MOVV $335, R12 JMP callbackasm1(SB) MOVV $336, R12 JMP callbackasm1(SB) MOVV $337, R12 JMP callbackasm1(SB) MOVV $338, R12 JMP callbackasm1(SB) MOVV $339, R12 JMP callbackasm1(SB) MOVV $340, R12 JMP callbackasm1(SB) MOVV $341, R12 JMP callbackasm1(SB) MOVV $342, R12 JMP callbackasm1(SB) MOVV $343, R12 JMP callbackasm1(SB) MOVV $344, R12 JMP callbackasm1(SB) MOVV $345, R12 JMP callbackasm1(SB) MOVV $346, R12 JMP callbackasm1(SB) MOVV $347, R12 JMP callbackasm1(SB) MOVV $348, R12 JMP callbackasm1(SB) MOVV $349, R12 JMP callbackasm1(SB) MOVV $350, R12 JMP callbackasm1(SB) MOVV $351, R12 JMP callbackasm1(SB) MOVV $352, R12 JMP callbackasm1(SB) MOVV $353, R12 JMP callbackasm1(SB) MOVV $354, R12 JMP callbackasm1(SB) MOVV $355, R12 JMP callbackasm1(SB) MOVV $356, R12 JMP callbackasm1(SB) MOVV $357, R12 JMP callbackasm1(SB) MOVV $358, R12 JMP callbackasm1(SB) MOVV $359, R12 JMP callbackasm1(SB) MOVV $360, R12 JMP callbackasm1(SB) MOVV $361, R12 JMP callbackasm1(SB) MOVV $362, R12 JMP callbackasm1(SB) MOVV $363, R12 JMP callbackasm1(SB) MOVV $364, R12 JMP callbackasm1(SB) MOVV $365, R12 JMP callbackasm1(SB) MOVV $366, R12 JMP callbackasm1(SB) MOVV $367, R12 JMP callbackasm1(SB) MOVV $368, R12 JMP callbackasm1(SB) MOVV $369, R12 JMP callbackasm1(SB) MOVV $370, R12 JMP callbackasm1(SB) MOVV $371, R12 JMP callbackasm1(SB) MOVV $372, R12 JMP callbackasm1(SB) MOVV $373, R12 JMP callbackasm1(SB) MOVV $374, R12 JMP callbackasm1(SB) MOVV $375, R12 JMP callbackasm1(SB) MOVV $376, R12 JMP callbackasm1(SB) MOVV $377, R12 JMP callbackasm1(SB) MOVV $378, R12 JMP callbackasm1(SB) MOVV $379, R12 JMP callbackasm1(SB) MOVV $380, R12 JMP callbackasm1(SB) MOVV $381, R12 JMP callbackasm1(SB) MOVV $382, R12 JMP callbackasm1(SB) MOVV $383, R12 JMP callbackasm1(SB) MOVV $384, R12 JMP callbackasm1(SB) MOVV $385, R12 JMP callbackasm1(SB) MOVV $386, R12 JMP callbackasm1(SB) MOVV $387, R12 JMP callbackasm1(SB) MOVV $388, R12 JMP callbackasm1(SB) MOVV $389, R12 JMP callbackasm1(SB) MOVV $390, R12 JMP callbackasm1(SB) MOVV $391, R12 JMP callbackasm1(SB) MOVV $392, R12 JMP callbackasm1(SB) MOVV $393, R12 JMP callbackasm1(SB) MOVV $394, R12 JMP callbackasm1(SB) MOVV $395, R12 JMP callbackasm1(SB) MOVV $396, R12 JMP callbackasm1(SB) MOVV $397, R12 JMP callbackasm1(SB) MOVV $398, R12 JMP callbackasm1(SB) MOVV $399, R12 JMP callbackasm1(SB) MOVV $400, R12 JMP callbackasm1(SB) MOVV $401, R12 JMP callbackasm1(SB) MOVV $402, R12 JMP callbackasm1(SB) MOVV $403, R12 JMP callbackasm1(SB) MOVV $404, R12 JMP callbackasm1(SB) MOVV $405, R12 JMP callbackasm1(SB) MOVV $406, R12 JMP callbackasm1(SB) MOVV $407, R12 JMP callbackasm1(SB) MOVV $408, R12 JMP callbackasm1(SB) MOVV $409, R12 JMP callbackasm1(SB) MOVV $410, R12 JMP callbackasm1(SB) MOVV $411, R12 JMP callbackasm1(SB) MOVV $412, R12 JMP callbackasm1(SB) MOVV $413, R12 JMP callbackasm1(SB) MOVV $414, R12 JMP callbackasm1(SB) MOVV $415, R12 JMP callbackasm1(SB) MOVV $416, R12 JMP callbackasm1(SB) MOVV $417, R12 JMP callbackasm1(SB) MOVV $418, R12 JMP callbackasm1(SB) MOVV $419, R12 JMP callbackasm1(SB) MOVV $420, R12 JMP callbackasm1(SB) MOVV $421, R12 JMP callbackasm1(SB) MOVV $422, R12 JMP callbackasm1(SB) MOVV $423, R12 JMP callbackasm1(SB) MOVV $424, R12 JMP callbackasm1(SB) MOVV $425, R12 JMP callbackasm1(SB) MOVV $426, R12 JMP callbackasm1(SB) MOVV $427, R12 JMP callbackasm1(SB) MOVV $428, R12 JMP callbackasm1(SB) MOVV $429, R12 JMP callbackasm1(SB) MOVV $430, R12 JMP callbackasm1(SB) MOVV $431, R12 JMP callbackasm1(SB) MOVV $432, R12 JMP callbackasm1(SB) MOVV $433, R12 JMP callbackasm1(SB) MOVV $434, R12 JMP callbackasm1(SB) MOVV $435, R12 JMP callbackasm1(SB) MOVV $436, R12 JMP callbackasm1(SB) MOVV $437, R12 JMP callbackasm1(SB) MOVV $438, R12 JMP callbackasm1(SB) MOVV $439, R12 JMP callbackasm1(SB) MOVV $440, R12 JMP callbackasm1(SB) MOVV $441, R12 JMP callbackasm1(SB) MOVV $442, R12 JMP callbackasm1(SB) MOVV $443, R12 JMP callbackasm1(SB) MOVV $444, R12 JMP callbackasm1(SB) MOVV $445, R12 JMP callbackasm1(SB) MOVV $446, R12 JMP callbackasm1(SB) MOVV $447, R12 JMP callbackasm1(SB) MOVV $448, R12 JMP callbackasm1(SB) MOVV $449, R12 JMP callbackasm1(SB) MOVV $450, R12 JMP callbackasm1(SB) MOVV $451, R12 JMP callbackasm1(SB) MOVV $452, R12 JMP callbackasm1(SB) MOVV $453, R12 JMP callbackasm1(SB) MOVV $454, R12 JMP callbackasm1(SB) MOVV $455, R12 JMP callbackasm1(SB) MOVV $456, R12 JMP callbackasm1(SB) MOVV $457, R12 JMP callbackasm1(SB) MOVV $458, R12 JMP callbackasm1(SB) MOVV $459, R12 JMP callbackasm1(SB) MOVV $460, R12 JMP callbackasm1(SB) MOVV $461, R12 JMP callbackasm1(SB) MOVV $462, R12 JMP callbackasm1(SB) MOVV $463, R12 JMP callbackasm1(SB) MOVV $464, R12 JMP callbackasm1(SB) MOVV $465, R12 JMP callbackasm1(SB) MOVV $466, R12 JMP callbackasm1(SB) MOVV $467, R12 JMP callbackasm1(SB) MOVV $468, R12 JMP callbackasm1(SB) MOVV $469, R12 JMP callbackasm1(SB) MOVV $470, R12 JMP callbackasm1(SB) MOVV $471, R12 JMP callbackasm1(SB) MOVV $472, R12 JMP callbackasm1(SB) MOVV $473, R12 JMP callbackasm1(SB) MOVV $474, R12 JMP callbackasm1(SB) MOVV $475, R12 JMP callbackasm1(SB) MOVV $476, R12 JMP callbackasm1(SB) MOVV $477, R12 JMP callbackasm1(SB) MOVV $478, R12 JMP callbackasm1(SB) MOVV $479, R12 JMP callbackasm1(SB) MOVV $480, R12 JMP callbackasm1(SB) MOVV $481, R12 JMP callbackasm1(SB) MOVV $482, R12 JMP callbackasm1(SB) MOVV $483, R12 JMP callbackasm1(SB) MOVV $484, R12 JMP callbackasm1(SB) MOVV $485, R12 JMP callbackasm1(SB) MOVV $486, R12 JMP callbackasm1(SB) MOVV $487, R12 JMP callbackasm1(SB) MOVV $488, R12 JMP callbackasm1(SB) MOVV $489, R12 JMP callbackasm1(SB) MOVV $490, R12 JMP callbackasm1(SB) MOVV $491, R12 JMP callbackasm1(SB) MOVV $492, R12 JMP callbackasm1(SB) MOVV $493, R12 JMP callbackasm1(SB) MOVV $494, R12 JMP callbackasm1(SB) MOVV $495, R12 JMP callbackasm1(SB) MOVV $496, R12 JMP callbackasm1(SB) MOVV $497, R12 JMP callbackasm1(SB) MOVV $498, R12 JMP callbackasm1(SB) MOVV $499, R12 JMP callbackasm1(SB) MOVV $500, R12 JMP callbackasm1(SB) MOVV $501, R12 JMP callbackasm1(SB) MOVV $502, R12 JMP callbackasm1(SB) MOVV $503, R12 JMP callbackasm1(SB) MOVV $504, R12 JMP callbackasm1(SB) MOVV $505, R12 JMP callbackasm1(SB) MOVV $506, R12 JMP callbackasm1(SB) MOVV $507, R12 JMP callbackasm1(SB) MOVV $508, R12 JMP callbackasm1(SB) MOVV $509, R12 JMP callbackasm1(SB) MOVV $510, R12 JMP callbackasm1(SB) MOVV $511, R12 JMP callbackasm1(SB) MOVV $512, R12 JMP callbackasm1(SB) MOVV $513, R12 JMP callbackasm1(SB) MOVV $514, R12 JMP callbackasm1(SB) MOVV $515, R12 JMP callbackasm1(SB) MOVV $516, R12 JMP callbackasm1(SB) MOVV $517, R12 JMP callbackasm1(SB) MOVV $518, R12 JMP callbackasm1(SB) MOVV $519, R12 JMP callbackasm1(SB) MOVV $520, R12 JMP callbackasm1(SB) MOVV $521, R12 JMP callbackasm1(SB) MOVV $522, R12 JMP callbackasm1(SB) MOVV $523, R12 JMP callbackasm1(SB) MOVV $524, R12 JMP callbackasm1(SB) MOVV $525, R12 JMP callbackasm1(SB) MOVV $526, R12 JMP callbackasm1(SB) MOVV $527, R12 JMP callbackasm1(SB) MOVV $528, R12 JMP callbackasm1(SB) MOVV $529, R12 JMP callbackasm1(SB) MOVV $530, R12 JMP callbackasm1(SB) MOVV $531, R12 JMP callbackasm1(SB) MOVV $532, R12 JMP callbackasm1(SB) MOVV $533, R12 JMP callbackasm1(SB) MOVV $534, R12 JMP callbackasm1(SB) MOVV $535, R12 JMP callbackasm1(SB) MOVV $536, R12 JMP callbackasm1(SB) MOVV $537, R12 JMP callbackasm1(SB) MOVV $538, R12 JMP callbackasm1(SB) MOVV $539, R12 JMP callbackasm1(SB) MOVV $540, R12 JMP callbackasm1(SB) MOVV $541, R12 JMP callbackasm1(SB) MOVV $542, R12 JMP callbackasm1(SB) MOVV $543, R12 JMP callbackasm1(SB) MOVV $544, R12 JMP callbackasm1(SB) MOVV $545, R12 JMP callbackasm1(SB) MOVV $546, R12 JMP callbackasm1(SB) MOVV $547, R12 JMP callbackasm1(SB) MOVV $548, R12 JMP callbackasm1(SB) MOVV $549, R12 JMP callbackasm1(SB) MOVV $550, R12 JMP callbackasm1(SB) MOVV $551, R12 JMP callbackasm1(SB) MOVV $552, R12 JMP callbackasm1(SB) MOVV $553, R12 JMP callbackasm1(SB) MOVV $554, R12 JMP callbackasm1(SB) MOVV $555, R12 JMP callbackasm1(SB) MOVV $556, R12 JMP callbackasm1(SB) MOVV $557, R12 JMP callbackasm1(SB) MOVV $558, R12 JMP callbackasm1(SB) MOVV $559, R12 JMP callbackasm1(SB) MOVV $560, R12 JMP callbackasm1(SB) MOVV $561, R12 JMP callbackasm1(SB) MOVV $562, R12 JMP callbackasm1(SB) MOVV $563, R12 JMP callbackasm1(SB) MOVV $564, R12 JMP callbackasm1(SB) MOVV $565, R12 JMP callbackasm1(SB) MOVV $566, R12 JMP callbackasm1(SB) MOVV $567, R12 JMP callbackasm1(SB) MOVV $568, R12 JMP callbackasm1(SB) MOVV $569, R12 JMP callbackasm1(SB) MOVV $570, R12 JMP callbackasm1(SB) MOVV $571, R12 JMP callbackasm1(SB) MOVV $572, R12 JMP callbackasm1(SB) MOVV $573, R12 JMP callbackasm1(SB) MOVV $574, R12 JMP callbackasm1(SB) MOVV $575, R12 JMP callbackasm1(SB) MOVV $576, R12 JMP callbackasm1(SB) MOVV $577, R12 JMP callbackasm1(SB) MOVV $578, R12 JMP callbackasm1(SB) MOVV $579, R12 JMP callbackasm1(SB) MOVV $580, R12 JMP callbackasm1(SB) MOVV $581, R12 JMP callbackasm1(SB) MOVV $582, R12 JMP callbackasm1(SB) MOVV $583, R12 JMP callbackasm1(SB) MOVV $584, R12 JMP callbackasm1(SB) MOVV $585, R12 JMP callbackasm1(SB) MOVV $586, R12 JMP callbackasm1(SB) MOVV $587, R12 JMP callbackasm1(SB) MOVV $588, R12 JMP callbackasm1(SB) MOVV $589, R12 JMP callbackasm1(SB) MOVV $590, R12 JMP callbackasm1(SB) MOVV $591, R12 JMP callbackasm1(SB) MOVV $592, R12 JMP callbackasm1(SB) MOVV $593, R12 JMP callbackasm1(SB) MOVV $594, R12 JMP callbackasm1(SB) MOVV $595, R12 JMP callbackasm1(SB) MOVV $596, R12 JMP callbackasm1(SB) MOVV $597, R12 JMP callbackasm1(SB) MOVV $598, R12 JMP callbackasm1(SB) MOVV $599, R12 JMP callbackasm1(SB) MOVV $600, R12 JMP callbackasm1(SB) MOVV $601, R12 JMP callbackasm1(SB) MOVV $602, R12 JMP callbackasm1(SB) MOVV $603, R12 JMP callbackasm1(SB) MOVV $604, R12 JMP callbackasm1(SB) MOVV $605, R12 JMP callbackasm1(SB) MOVV $606, R12 JMP callbackasm1(SB) MOVV $607, R12 JMP callbackasm1(SB) MOVV $608, R12 JMP callbackasm1(SB) MOVV $609, R12 JMP callbackasm1(SB) MOVV $610, R12 JMP callbackasm1(SB) MOVV $611, R12 JMP callbackasm1(SB) MOVV $612, R12 JMP callbackasm1(SB) MOVV $613, R12 JMP callbackasm1(SB) MOVV $614, R12 JMP callbackasm1(SB) MOVV $615, R12 JMP callbackasm1(SB) MOVV $616, R12 JMP callbackasm1(SB) MOVV $617, R12 JMP callbackasm1(SB) MOVV $618, R12 JMP callbackasm1(SB) MOVV $619, R12 JMP callbackasm1(SB) MOVV $620, R12 JMP callbackasm1(SB) MOVV $621, R12 JMP callbackasm1(SB) MOVV $622, R12 JMP callbackasm1(SB) MOVV $623, R12 JMP callbackasm1(SB) MOVV $624, R12 JMP callbackasm1(SB) MOVV $625, R12 JMP callbackasm1(SB) MOVV $626, R12 JMP callbackasm1(SB) MOVV $627, R12 JMP callbackasm1(SB) MOVV $628, R12 JMP callbackasm1(SB) MOVV $629, R12 JMP callbackasm1(SB) MOVV $630, R12 JMP callbackasm1(SB) MOVV $631, R12 JMP callbackasm1(SB) MOVV $632, R12 JMP callbackasm1(SB) MOVV $633, R12 JMP callbackasm1(SB) MOVV $634, R12 JMP callbackasm1(SB) MOVV $635, R12 JMP callbackasm1(SB) MOVV $636, R12 JMP callbackasm1(SB) MOVV $637, R12 JMP callbackasm1(SB) MOVV $638, R12 JMP callbackasm1(SB) MOVV $639, R12 JMP callbackasm1(SB) MOVV $640, R12 JMP callbackasm1(SB) MOVV $641, R12 JMP callbackasm1(SB) MOVV $642, R12 JMP callbackasm1(SB) MOVV $643, R12 JMP callbackasm1(SB) MOVV $644, R12 JMP callbackasm1(SB) MOVV $645, R12 JMP callbackasm1(SB) MOVV $646, R12 JMP callbackasm1(SB) MOVV $647, R12 JMP callbackasm1(SB) MOVV $648, R12 JMP callbackasm1(SB) MOVV $649, R12 JMP callbackasm1(SB) MOVV $650, R12 JMP callbackasm1(SB) MOVV $651, R12 JMP callbackasm1(SB) MOVV $652, R12 JMP callbackasm1(SB) MOVV $653, R12 JMP callbackasm1(SB) MOVV $654, R12 JMP callbackasm1(SB) MOVV $655, R12 JMP callbackasm1(SB) MOVV $656, R12 JMP callbackasm1(SB) MOVV $657, R12 JMP callbackasm1(SB) MOVV $658, R12 JMP callbackasm1(SB) MOVV $659, R12 JMP callbackasm1(SB) MOVV $660, R12 JMP callbackasm1(SB) MOVV $661, R12 JMP callbackasm1(SB) MOVV $662, R12 JMP callbackasm1(SB) MOVV $663, R12 JMP callbackasm1(SB) MOVV $664, R12 JMP callbackasm1(SB) MOVV $665, R12 JMP callbackasm1(SB) MOVV $666, R12 JMP callbackasm1(SB) MOVV $667, R12 JMP callbackasm1(SB) MOVV $668, R12 JMP callbackasm1(SB) MOVV $669, R12 JMP callbackasm1(SB) MOVV $670, R12 JMP callbackasm1(SB) MOVV $671, R12 JMP callbackasm1(SB) MOVV $672, R12 JMP callbackasm1(SB) MOVV $673, R12 JMP callbackasm1(SB) MOVV $674, R12 JMP callbackasm1(SB) MOVV $675, R12 JMP callbackasm1(SB) MOVV $676, R12 JMP callbackasm1(SB) MOVV $677, R12 JMP callbackasm1(SB) MOVV $678, R12 JMP callbackasm1(SB) MOVV $679, R12 JMP callbackasm1(SB) MOVV $680, R12 JMP callbackasm1(SB) MOVV $681, R12 JMP callbackasm1(SB) MOVV $682, R12 JMP callbackasm1(SB) MOVV $683, R12 JMP callbackasm1(SB) MOVV $684, R12 JMP callbackasm1(SB) MOVV $685, R12 JMP callbackasm1(SB) MOVV $686, R12 JMP callbackasm1(SB) MOVV $687, R12 JMP callbackasm1(SB) MOVV $688, R12 JMP callbackasm1(SB) MOVV $689, R12 JMP callbackasm1(SB) MOVV $690, R12 JMP callbackasm1(SB) MOVV $691, R12 JMP callbackasm1(SB) MOVV $692, R12 JMP callbackasm1(SB) MOVV $693, R12 JMP callbackasm1(SB) MOVV $694, R12 JMP callbackasm1(SB) MOVV $695, R12 JMP callbackasm1(SB) MOVV $696, R12 JMP callbackasm1(SB) MOVV $697, R12 JMP callbackasm1(SB) MOVV $698, R12 JMP callbackasm1(SB) MOVV $699, R12 JMP callbackasm1(SB) MOVV $700, R12 JMP callbackasm1(SB) MOVV $701, R12 JMP callbackasm1(SB) MOVV $702, R12 JMP callbackasm1(SB) MOVV $703, R12 JMP callbackasm1(SB) MOVV $704, R12 JMP callbackasm1(SB) MOVV $705, R12 JMP callbackasm1(SB) MOVV $706, R12 JMP callbackasm1(SB) MOVV $707, R12 JMP callbackasm1(SB) MOVV $708, R12 JMP callbackasm1(SB) MOVV $709, R12 JMP callbackasm1(SB) MOVV $710, R12 JMP callbackasm1(SB) MOVV $711, R12 JMP callbackasm1(SB) MOVV $712, R12 JMP callbackasm1(SB) MOVV $713, R12 JMP callbackasm1(SB) MOVV $714, R12 JMP callbackasm1(SB) MOVV $715, R12 JMP callbackasm1(SB) MOVV $716, R12 JMP callbackasm1(SB) MOVV $717, R12 JMP callbackasm1(SB) MOVV $718, R12 JMP callbackasm1(SB) MOVV $719, R12 JMP callbackasm1(SB) MOVV $720, R12 JMP callbackasm1(SB) MOVV $721, R12 JMP callbackasm1(SB) MOVV $722, R12 JMP callbackasm1(SB) MOVV $723, R12 JMP callbackasm1(SB) MOVV $724, R12 JMP callbackasm1(SB) MOVV $725, R12 JMP callbackasm1(SB) MOVV $726, R12 JMP callbackasm1(SB) MOVV $727, R12 JMP callbackasm1(SB) MOVV $728, R12 JMP callbackasm1(SB) MOVV $729, R12 JMP callbackasm1(SB) MOVV $730, R12 JMP callbackasm1(SB) MOVV $731, R12 JMP callbackasm1(SB) MOVV $732, R12 JMP callbackasm1(SB) MOVV $733, R12 JMP callbackasm1(SB) MOVV $734, R12 JMP callbackasm1(SB) MOVV $735, R12 JMP callbackasm1(SB) MOVV $736, R12 JMP callbackasm1(SB) MOVV $737, R12 JMP callbackasm1(SB) MOVV $738, R12 JMP callbackasm1(SB) MOVV $739, R12 JMP callbackasm1(SB) MOVV $740, R12 JMP callbackasm1(SB) MOVV $741, R12 JMP callbackasm1(SB) MOVV $742, R12 JMP callbackasm1(SB) MOVV $743, R12 JMP callbackasm1(SB) MOVV $744, R12 JMP callbackasm1(SB) MOVV $745, R12 JMP callbackasm1(SB) MOVV $746, R12 JMP callbackasm1(SB) MOVV $747, R12 JMP callbackasm1(SB) MOVV $748, R12 JMP callbackasm1(SB) MOVV $749, R12 JMP callbackasm1(SB) MOVV $750, R12 JMP callbackasm1(SB) MOVV $751, R12 JMP callbackasm1(SB) MOVV $752, R12 JMP callbackasm1(SB) MOVV $753, R12 JMP callbackasm1(SB) MOVV $754, R12 JMP callbackasm1(SB) MOVV $755, R12 JMP callbackasm1(SB) MOVV $756, R12 JMP callbackasm1(SB) MOVV $757, R12 JMP callbackasm1(SB) MOVV $758, R12 JMP callbackasm1(SB) MOVV $759, R12 JMP callbackasm1(SB) MOVV $760, R12 JMP callbackasm1(SB) MOVV $761, R12 JMP callbackasm1(SB) MOVV $762, R12 JMP callbackasm1(SB) MOVV $763, R12 JMP callbackasm1(SB) MOVV $764, R12 JMP callbackasm1(SB) MOVV $765, R12 JMP callbackasm1(SB) MOVV $766, R12 JMP callbackasm1(SB) MOVV $767, R12 JMP callbackasm1(SB) MOVV $768, R12 JMP callbackasm1(SB) MOVV $769, R12 JMP callbackasm1(SB) MOVV $770, R12 JMP callbackasm1(SB) MOVV $771, R12 JMP callbackasm1(SB) MOVV $772, R12 JMP callbackasm1(SB) MOVV $773, R12 JMP callbackasm1(SB) MOVV $774, R12 JMP callbackasm1(SB) MOVV $775, R12 JMP callbackasm1(SB) MOVV $776, R12 JMP callbackasm1(SB) MOVV $777, R12 JMP callbackasm1(SB) MOVV $778, R12 JMP callbackasm1(SB) MOVV $779, R12 JMP callbackasm1(SB) MOVV $780, R12 JMP callbackasm1(SB) MOVV $781, R12 JMP callbackasm1(SB) MOVV $782, R12 JMP callbackasm1(SB) MOVV $783, R12 JMP callbackasm1(SB) MOVV $784, R12 JMP callbackasm1(SB) MOVV $785, R12 JMP callbackasm1(SB) MOVV $786, R12 JMP callbackasm1(SB) MOVV $787, R12 JMP callbackasm1(SB) MOVV $788, R12 JMP callbackasm1(SB) MOVV $789, R12 JMP callbackasm1(SB) MOVV $790, R12 JMP callbackasm1(SB) MOVV $791, R12 JMP callbackasm1(SB) MOVV $792, R12 JMP callbackasm1(SB) MOVV $793, R12 JMP callbackasm1(SB) MOVV $794, R12 JMP callbackasm1(SB) MOVV $795, R12 JMP callbackasm1(SB) MOVV $796, R12 JMP callbackasm1(SB) MOVV $797, R12 JMP callbackasm1(SB) MOVV $798, R12 JMP callbackasm1(SB) MOVV $799, R12 JMP callbackasm1(SB) MOVV $800, R12 JMP callbackasm1(SB) MOVV $801, R12 JMP callbackasm1(SB) MOVV $802, R12 JMP callbackasm1(SB) MOVV $803, R12 JMP callbackasm1(SB) MOVV $804, R12 JMP callbackasm1(SB) MOVV $805, R12 JMP callbackasm1(SB) MOVV $806, R12 JMP callbackasm1(SB) MOVV $807, R12 JMP callbackasm1(SB) MOVV $808, R12 JMP callbackasm1(SB) MOVV $809, R12 JMP callbackasm1(SB) MOVV $810, R12 JMP callbackasm1(SB) MOVV $811, R12 JMP callbackasm1(SB) MOVV $812, R12 JMP callbackasm1(SB) MOVV $813, R12 JMP callbackasm1(SB) MOVV $814, R12 JMP callbackasm1(SB) MOVV $815, R12 JMP callbackasm1(SB) MOVV $816, R12 JMP callbackasm1(SB) MOVV $817, R12 JMP callbackasm1(SB) MOVV $818, R12 JMP callbackasm1(SB) MOVV $819, R12 JMP callbackasm1(SB) MOVV $820, R12 JMP callbackasm1(SB) MOVV $821, R12 JMP callbackasm1(SB) MOVV $822, R12 JMP callbackasm1(SB) MOVV $823, R12 JMP callbackasm1(SB) MOVV $824, R12 JMP callbackasm1(SB) MOVV $825, R12 JMP callbackasm1(SB) MOVV $826, R12 JMP callbackasm1(SB) MOVV $827, R12 JMP callbackasm1(SB) MOVV $828, R12 JMP callbackasm1(SB) MOVV $829, R12 JMP callbackasm1(SB) MOVV $830, R12 JMP callbackasm1(SB) MOVV $831, R12 JMP callbackasm1(SB) MOVV $832, R12 JMP callbackasm1(SB) MOVV $833, R12 JMP callbackasm1(SB) MOVV $834, R12 JMP callbackasm1(SB) MOVV $835, R12 JMP callbackasm1(SB) MOVV $836, R12 JMP callbackasm1(SB) MOVV $837, R12 JMP callbackasm1(SB) MOVV $838, R12 JMP callbackasm1(SB) MOVV $839, R12 JMP callbackasm1(SB) MOVV $840, R12 JMP callbackasm1(SB) MOVV $841, R12 JMP callbackasm1(SB) MOVV $842, R12 JMP callbackasm1(SB) MOVV $843, R12 JMP callbackasm1(SB) MOVV $844, R12 JMP callbackasm1(SB) MOVV $845, R12 JMP callbackasm1(SB) MOVV $846, R12 JMP callbackasm1(SB) MOVV $847, R12 JMP callbackasm1(SB) MOVV $848, R12 JMP callbackasm1(SB) MOVV $849, R12 JMP callbackasm1(SB) MOVV $850, R12 JMP callbackasm1(SB) MOVV $851, R12 JMP callbackasm1(SB) MOVV $852, R12 JMP callbackasm1(SB) MOVV $853, R12 JMP callbackasm1(SB) MOVV $854, R12 JMP callbackasm1(SB) MOVV $855, R12 JMP callbackasm1(SB) MOVV $856, R12 JMP callbackasm1(SB) MOVV $857, R12 JMP callbackasm1(SB) MOVV $858, R12 JMP callbackasm1(SB) MOVV $859, R12 JMP callbackasm1(SB) MOVV $860, R12 JMP callbackasm1(SB) MOVV $861, R12 JMP callbackasm1(SB) MOVV $862, R12 JMP callbackasm1(SB) MOVV $863, R12 JMP callbackasm1(SB) MOVV $864, R12 JMP callbackasm1(SB) MOVV $865, R12 JMP callbackasm1(SB) MOVV $866, R12 JMP callbackasm1(SB) MOVV $867, R12 JMP callbackasm1(SB) MOVV $868, R12 JMP callbackasm1(SB) MOVV $869, R12 JMP callbackasm1(SB) MOVV $870, R12 JMP callbackasm1(SB) MOVV $871, R12 JMP callbackasm1(SB) MOVV $872, R12 JMP callbackasm1(SB) MOVV $873, R12 JMP callbackasm1(SB) MOVV $874, R12 JMP callbackasm1(SB) MOVV $875, R12 JMP callbackasm1(SB) MOVV $876, R12 JMP callbackasm1(SB) MOVV $877, R12 JMP callbackasm1(SB) MOVV $878, R12 JMP callbackasm1(SB) MOVV $879, R12 JMP callbackasm1(SB) MOVV $880, R12 JMP callbackasm1(SB) MOVV $881, R12 JMP callbackasm1(SB) MOVV $882, R12 JMP callbackasm1(SB) MOVV $883, R12 JMP callbackasm1(SB) MOVV $884, R12 JMP callbackasm1(SB) MOVV $885, R12 JMP callbackasm1(SB) MOVV $886, R12 JMP callbackasm1(SB) MOVV $887, R12 JMP callbackasm1(SB) MOVV $888, R12 JMP callbackasm1(SB) MOVV $889, R12 JMP callbackasm1(SB) MOVV $890, R12 JMP callbackasm1(SB) MOVV $891, R12 JMP callbackasm1(SB) MOVV $892, R12 JMP callbackasm1(SB) MOVV $893, R12 JMP callbackasm1(SB) MOVV $894, R12 JMP callbackasm1(SB) MOVV $895, R12 JMP callbackasm1(SB) MOVV $896, R12 JMP callbackasm1(SB) MOVV $897, R12 JMP callbackasm1(SB) MOVV $898, R12 JMP callbackasm1(SB) MOVV $899, R12 JMP callbackasm1(SB) MOVV $900, R12 JMP callbackasm1(SB) MOVV $901, R12 JMP callbackasm1(SB) MOVV $902, R12 JMP callbackasm1(SB) MOVV $903, R12 JMP callbackasm1(SB) MOVV $904, R12 JMP callbackasm1(SB) MOVV $905, R12 JMP callbackasm1(SB) MOVV $906, R12 JMP callbackasm1(SB) MOVV $907, R12 JMP callbackasm1(SB) MOVV $908, R12 JMP callbackasm1(SB) MOVV $909, R12 JMP callbackasm1(SB) MOVV $910, R12 JMP callbackasm1(SB) MOVV $911, R12 JMP callbackasm1(SB) MOVV $912, R12 JMP callbackasm1(SB) MOVV $913, R12 JMP callbackasm1(SB) MOVV $914, R12 JMP callbackasm1(SB) MOVV $915, R12 JMP callbackasm1(SB) MOVV $916, R12 JMP callbackasm1(SB) MOVV $917, R12 JMP callbackasm1(SB) MOVV $918, R12 JMP callbackasm1(SB) MOVV $919, R12 JMP callbackasm1(SB) MOVV $920, R12 JMP callbackasm1(SB) MOVV $921, R12 JMP callbackasm1(SB) MOVV $922, R12 JMP callbackasm1(SB) MOVV $923, R12 JMP callbackasm1(SB) MOVV $924, R12 JMP callbackasm1(SB) MOVV $925, R12 JMP callbackasm1(SB) MOVV $926, R12 JMP callbackasm1(SB) MOVV $927, R12 JMP callbackasm1(SB) MOVV $928, R12 JMP callbackasm1(SB) MOVV $929, R12 JMP callbackasm1(SB) MOVV $930, R12 JMP callbackasm1(SB) MOVV $931, R12 JMP callbackasm1(SB) MOVV $932, R12 JMP callbackasm1(SB) MOVV $933, R12 JMP callbackasm1(SB) MOVV $934, R12 JMP callbackasm1(SB) MOVV $935, R12 JMP callbackasm1(SB) MOVV $936, R12 JMP callbackasm1(SB) MOVV $937, R12 JMP callbackasm1(SB) MOVV $938, R12 JMP callbackasm1(SB) MOVV $939, R12 JMP callbackasm1(SB) MOVV $940, R12 JMP callbackasm1(SB) MOVV $941, R12 JMP callbackasm1(SB) MOVV $942, R12 JMP callbackasm1(SB) MOVV $943, R12 JMP callbackasm1(SB) MOVV $944, R12 JMP callbackasm1(SB) MOVV $945, R12 JMP callbackasm1(SB) MOVV $946, R12 JMP callbackasm1(SB) MOVV $947, R12 JMP callbackasm1(SB) MOVV $948, R12 JMP callbackasm1(SB) MOVV $949, R12 JMP callbackasm1(SB) MOVV $950, R12 JMP callbackasm1(SB) MOVV $951, R12 JMP callbackasm1(SB) MOVV $952, R12 JMP callbackasm1(SB) MOVV $953, R12 JMP callbackasm1(SB) MOVV $954, R12 JMP callbackasm1(SB) MOVV $955, R12 JMP callbackasm1(SB) MOVV $956, R12 JMP callbackasm1(SB) MOVV $957, R12 JMP callbackasm1(SB) MOVV $958, R12 JMP callbackasm1(SB) MOVV $959, R12 JMP callbackasm1(SB) MOVV $960, R12 JMP callbackasm1(SB) MOVV $961, R12 JMP callbackasm1(SB) MOVV $962, R12 JMP callbackasm1(SB) MOVV $963, R12 JMP callbackasm1(SB) MOVV $964, R12 JMP callbackasm1(SB) MOVV $965, R12 JMP callbackasm1(SB) MOVV $966, R12 JMP callbackasm1(SB) MOVV $967, R12 JMP callbackasm1(SB) MOVV $968, R12 JMP callbackasm1(SB) MOVV $969, R12 JMP callbackasm1(SB) MOVV $970, R12 JMP callbackasm1(SB) MOVV $971, R12 JMP callbackasm1(SB) MOVV $972, R12 JMP callbackasm1(SB) MOVV $973, R12 JMP callbackasm1(SB) MOVV $974, R12 JMP callbackasm1(SB) MOVV $975, R12 JMP callbackasm1(SB) MOVV $976, R12 JMP callbackasm1(SB) MOVV $977, R12 JMP callbackasm1(SB) MOVV $978, R12 JMP callbackasm1(SB) MOVV $979, R12 JMP callbackasm1(SB) MOVV $980, R12 JMP callbackasm1(SB) MOVV $981, R12 JMP callbackasm1(SB) MOVV $982, R12 JMP callbackasm1(SB) MOVV $983, R12 JMP callbackasm1(SB) MOVV $984, R12 JMP callbackasm1(SB) MOVV $985, R12 JMP callbackasm1(SB) MOVV $986, R12 JMP callbackasm1(SB) MOVV $987, R12 JMP callbackasm1(SB) MOVV $988, R12 JMP callbackasm1(SB) MOVV $989, R12 JMP callbackasm1(SB) MOVV $990, R12 JMP callbackasm1(SB) MOVV $991, R12 JMP callbackasm1(SB) MOVV $992, R12 JMP callbackasm1(SB) MOVV $993, R12 JMP callbackasm1(SB) MOVV $994, R12 JMP callbackasm1(SB) MOVV $995, R12 JMP callbackasm1(SB) MOVV $996, R12 JMP callbackasm1(SB) MOVV $997, R12 JMP callbackasm1(SB) MOVV $998, R12 JMP callbackasm1(SB) MOVV $999, R12 JMP callbackasm1(SB) MOVV $1000, R12 JMP callbackasm1(SB) MOVV $1001, R12 JMP callbackasm1(SB) MOVV $1002, R12 JMP callbackasm1(SB) MOVV $1003, R12 JMP callbackasm1(SB) MOVV $1004, R12 JMP callbackasm1(SB) MOVV $1005, R12 JMP callbackasm1(SB) MOVV $1006, R12 JMP callbackasm1(SB) MOVV $1007, R12 JMP callbackasm1(SB) MOVV $1008, R12 JMP callbackasm1(SB) MOVV $1009, R12 JMP callbackasm1(SB) MOVV $1010, R12 JMP callbackasm1(SB) MOVV $1011, R12 JMP callbackasm1(SB) MOVV $1012, R12 JMP callbackasm1(SB) MOVV $1013, R12 JMP callbackasm1(SB) MOVV $1014, R12 JMP callbackasm1(SB) MOVV $1015, R12 JMP callbackasm1(SB) MOVV $1016, R12 JMP callbackasm1(SB) MOVV $1017, R12 JMP callbackasm1(SB) MOVV $1018, R12 JMP callbackasm1(SB) MOVV $1019, R12 JMP callbackasm1(SB) MOVV $1020, R12 JMP callbackasm1(SB) MOVV $1021, R12 JMP callbackasm1(SB) MOVV $1022, R12 JMP callbackasm1(SB) MOVV $1023, R12 JMP callbackasm1(SB) MOVV $1024, R12 JMP callbackasm1(SB) MOVV $1025, R12 JMP callbackasm1(SB) MOVV $1026, R12 JMP callbackasm1(SB) MOVV $1027, R12 JMP callbackasm1(SB) MOVV $1028, R12 JMP callbackasm1(SB) MOVV $1029, R12 JMP callbackasm1(SB) MOVV $1030, R12 JMP callbackasm1(SB) MOVV $1031, R12 JMP callbackasm1(SB) MOVV $1032, R12 JMP callbackasm1(SB) MOVV $1033, R12 JMP callbackasm1(SB) MOVV $1034, R12 JMP callbackasm1(SB) MOVV $1035, R12 JMP callbackasm1(SB) MOVV $1036, R12 JMP callbackasm1(SB) MOVV $1037, R12 JMP callbackasm1(SB) MOVV $1038, R12 JMP callbackasm1(SB) MOVV $1039, R12 JMP callbackasm1(SB) MOVV $1040, R12 JMP callbackasm1(SB) MOVV $1041, R12 JMP callbackasm1(SB) MOVV $1042, R12 JMP callbackasm1(SB) MOVV $1043, R12 JMP callbackasm1(SB) MOVV $1044, R12 JMP callbackasm1(SB) MOVV $1045, R12 JMP callbackasm1(SB) MOVV $1046, R12 JMP callbackasm1(SB) MOVV $1047, R12 JMP callbackasm1(SB) MOVV $1048, R12 JMP callbackasm1(SB) MOVV $1049, R12 JMP callbackasm1(SB) MOVV $1050, R12 JMP callbackasm1(SB) MOVV $1051, R12 JMP callbackasm1(SB) MOVV $1052, R12 JMP callbackasm1(SB) MOVV $1053, R12 JMP callbackasm1(SB) MOVV $1054, R12 JMP callbackasm1(SB) MOVV $1055, R12 JMP callbackasm1(SB) MOVV $1056, R12 JMP callbackasm1(SB) MOVV $1057, R12 JMP callbackasm1(SB) MOVV $1058, R12 JMP callbackasm1(SB) MOVV $1059, R12 JMP callbackasm1(SB) MOVV $1060, R12 JMP callbackasm1(SB) MOVV $1061, R12 JMP callbackasm1(SB) MOVV $1062, R12 JMP callbackasm1(SB) MOVV $1063, R12 JMP callbackasm1(SB) MOVV $1064, R12 JMP callbackasm1(SB) MOVV $1065, R12 JMP callbackasm1(SB) MOVV $1066, R12 JMP callbackasm1(SB) MOVV $1067, R12 JMP callbackasm1(SB) MOVV $1068, R12 JMP callbackasm1(SB) MOVV $1069, R12 JMP callbackasm1(SB) MOVV $1070, R12 JMP callbackasm1(SB) MOVV $1071, R12 JMP callbackasm1(SB) MOVV $1072, R12 JMP callbackasm1(SB) MOVV $1073, R12 JMP callbackasm1(SB) MOVV $1074, R12 JMP callbackasm1(SB) MOVV $1075, R12 JMP callbackasm1(SB) MOVV $1076, R12 JMP callbackasm1(SB) MOVV $1077, R12 JMP callbackasm1(SB) MOVV $1078, R12 JMP callbackasm1(SB) MOVV $1079, R12 JMP callbackasm1(SB) MOVV $1080, R12 JMP callbackasm1(SB) MOVV $1081, R12 JMP callbackasm1(SB) MOVV $1082, R12 JMP callbackasm1(SB) MOVV $1083, R12 JMP callbackasm1(SB) MOVV $1084, R12 JMP callbackasm1(SB) MOVV $1085, R12 JMP callbackasm1(SB) MOVV $1086, R12 JMP callbackasm1(SB) MOVV $1087, R12 JMP callbackasm1(SB) MOVV $1088, R12 JMP callbackasm1(SB) MOVV $1089, R12 JMP callbackasm1(SB) MOVV $1090, R12 JMP callbackasm1(SB) MOVV $1091, R12 JMP callbackasm1(SB) MOVV $1092, R12 JMP callbackasm1(SB) MOVV $1093, R12 JMP callbackasm1(SB) MOVV $1094, R12 JMP callbackasm1(SB) MOVV $1095, R12 JMP callbackasm1(SB) MOVV $1096, R12 JMP callbackasm1(SB) MOVV $1097, R12 JMP callbackasm1(SB) MOVV $1098, R12 JMP callbackasm1(SB) MOVV $1099, R12 JMP callbackasm1(SB) MOVV $1100, R12 JMP callbackasm1(SB) MOVV $1101, R12 JMP callbackasm1(SB) MOVV $1102, R12 JMP callbackasm1(SB) MOVV $1103, R12 JMP callbackasm1(SB) MOVV $1104, R12 JMP callbackasm1(SB) MOVV $1105, R12 JMP callbackasm1(SB) MOVV $1106, R12 JMP callbackasm1(SB) MOVV $1107, R12 JMP callbackasm1(SB) MOVV $1108, R12 JMP callbackasm1(SB) MOVV $1109, R12 JMP callbackasm1(SB) MOVV $1110, R12 JMP callbackasm1(SB) MOVV $1111, R12 JMP callbackasm1(SB) MOVV $1112, R12 JMP callbackasm1(SB) MOVV $1113, R12 JMP callbackasm1(SB) MOVV $1114, R12 JMP callbackasm1(SB) MOVV $1115, R12 JMP callbackasm1(SB) MOVV $1116, R12 JMP callbackasm1(SB) MOVV $1117, R12 JMP callbackasm1(SB) MOVV $1118, R12 JMP callbackasm1(SB) MOVV $1119, R12 JMP callbackasm1(SB) MOVV $1120, R12 JMP callbackasm1(SB) MOVV $1121, R12 JMP callbackasm1(SB) MOVV $1122, R12 JMP callbackasm1(SB) MOVV $1123, R12 JMP callbackasm1(SB) MOVV $1124, R12 JMP callbackasm1(SB) MOVV $1125, R12 JMP callbackasm1(SB) MOVV $1126, R12 JMP callbackasm1(SB) MOVV $1127, R12 JMP callbackasm1(SB) MOVV $1128, R12 JMP callbackasm1(SB) MOVV $1129, R12 JMP callbackasm1(SB) MOVV $1130, R12 JMP callbackasm1(SB) MOVV $1131, R12 JMP callbackasm1(SB) MOVV $1132, R12 JMP callbackasm1(SB) MOVV $1133, R12 JMP callbackasm1(SB) MOVV $1134, R12 JMP callbackasm1(SB) MOVV $1135, R12 JMP callbackasm1(SB) MOVV $1136, R12 JMP callbackasm1(SB) MOVV $1137, R12 JMP callbackasm1(SB) MOVV $1138, R12 JMP callbackasm1(SB) MOVV $1139, R12 JMP callbackasm1(SB) MOVV $1140, R12 JMP callbackasm1(SB) MOVV $1141, R12 JMP callbackasm1(SB) MOVV $1142, R12 JMP callbackasm1(SB) MOVV $1143, R12 JMP callbackasm1(SB) MOVV $1144, R12 JMP callbackasm1(SB) MOVV $1145, R12 JMP callbackasm1(SB) MOVV $1146, R12 JMP callbackasm1(SB) MOVV $1147, R12 JMP callbackasm1(SB) MOVV $1148, R12 JMP callbackasm1(SB) MOVV $1149, R12 JMP callbackasm1(SB) MOVV $1150, R12 JMP callbackasm1(SB) MOVV $1151, R12 JMP callbackasm1(SB) MOVV $1152, R12 JMP callbackasm1(SB) MOVV $1153, R12 JMP callbackasm1(SB) MOVV $1154, R12 JMP callbackasm1(SB) MOVV $1155, R12 JMP callbackasm1(SB) MOVV $1156, R12 JMP callbackasm1(SB) MOVV $1157, R12 JMP callbackasm1(SB) MOVV $1158, R12 JMP callbackasm1(SB) MOVV $1159, R12 JMP callbackasm1(SB) MOVV $1160, R12 JMP callbackasm1(SB) MOVV $1161, R12 JMP callbackasm1(SB) MOVV $1162, R12 JMP callbackasm1(SB) MOVV $1163, R12 JMP callbackasm1(SB) MOVV $1164, R12 JMP callbackasm1(SB) MOVV $1165, R12 JMP callbackasm1(SB) MOVV $1166, R12 JMP callbackasm1(SB) MOVV $1167, R12 JMP callbackasm1(SB) MOVV $1168, R12 JMP callbackasm1(SB) MOVV $1169, R12 JMP callbackasm1(SB) MOVV $1170, R12 JMP callbackasm1(SB) MOVV $1171, R12 JMP callbackasm1(SB) MOVV $1172, R12 JMP callbackasm1(SB) MOVV $1173, R12 JMP callbackasm1(SB) MOVV $1174, R12 JMP callbackasm1(SB) MOVV $1175, R12 JMP callbackasm1(SB) MOVV $1176, R12 JMP callbackasm1(SB) MOVV $1177, R12 JMP callbackasm1(SB) MOVV $1178, R12 JMP callbackasm1(SB) MOVV $1179, R12 JMP callbackasm1(SB) MOVV $1180, R12 JMP callbackasm1(SB) MOVV $1181, R12 JMP callbackasm1(SB) MOVV $1182, R12 JMP callbackasm1(SB) MOVV $1183, R12 JMP callbackasm1(SB) MOVV $1184, R12 JMP callbackasm1(SB) MOVV $1185, R12 JMP callbackasm1(SB) MOVV $1186, R12 JMP callbackasm1(SB) MOVV $1187, R12 JMP callbackasm1(SB) MOVV $1188, R12 JMP callbackasm1(SB) MOVV $1189, R12 JMP callbackasm1(SB) MOVV $1190, R12 JMP callbackasm1(SB) MOVV $1191, R12 JMP callbackasm1(SB) MOVV $1192, R12 JMP callbackasm1(SB) MOVV $1193, R12 JMP callbackasm1(SB) MOVV $1194, R12 JMP callbackasm1(SB) MOVV $1195, R12 JMP callbackasm1(SB) MOVV $1196, R12 JMP callbackasm1(SB) MOVV $1197, R12 JMP callbackasm1(SB) MOVV $1198, R12 JMP callbackasm1(SB) MOVV $1199, R12 JMP callbackasm1(SB) MOVV $1200, R12 JMP callbackasm1(SB) MOVV $1201, R12 JMP callbackasm1(SB) MOVV $1202, R12 JMP callbackasm1(SB) MOVV $1203, R12 JMP callbackasm1(SB) MOVV $1204, R12 JMP callbackasm1(SB) MOVV $1205, R12 JMP callbackasm1(SB) MOVV $1206, R12 JMP callbackasm1(SB) MOVV $1207, R12 JMP callbackasm1(SB) MOVV $1208, R12 JMP callbackasm1(SB) MOVV $1209, R12 JMP callbackasm1(SB) MOVV $1210, R12 JMP callbackasm1(SB) MOVV $1211, R12 JMP callbackasm1(SB) MOVV $1212, R12 JMP callbackasm1(SB) MOVV $1213, R12 JMP callbackasm1(SB) MOVV $1214, R12 JMP callbackasm1(SB) MOVV $1215, R12 JMP callbackasm1(SB) MOVV $1216, R12 JMP callbackasm1(SB) MOVV $1217, R12 JMP callbackasm1(SB) MOVV $1218, R12 JMP callbackasm1(SB) MOVV $1219, R12 JMP callbackasm1(SB) MOVV $1220, R12 JMP callbackasm1(SB) MOVV $1221, R12 JMP callbackasm1(SB) MOVV $1222, R12 JMP callbackasm1(SB) MOVV $1223, R12 JMP callbackasm1(SB) MOVV $1224, R12 JMP callbackasm1(SB) MOVV $1225, R12 JMP callbackasm1(SB) MOVV $1226, R12 JMP callbackasm1(SB) MOVV $1227, R12 JMP callbackasm1(SB) MOVV $1228, R12 JMP callbackasm1(SB) MOVV $1229, R12 JMP callbackasm1(SB) MOVV $1230, R12 JMP callbackasm1(SB) MOVV $1231, R12 JMP callbackasm1(SB) MOVV $1232, R12 JMP callbackasm1(SB) MOVV $1233, R12 JMP callbackasm1(SB) MOVV $1234, R12 JMP callbackasm1(SB) MOVV $1235, R12 JMP callbackasm1(SB) MOVV $1236, R12 JMP callbackasm1(SB) MOVV $1237, R12 JMP callbackasm1(SB) MOVV $1238, R12 JMP callbackasm1(SB) MOVV $1239, R12 JMP callbackasm1(SB) MOVV $1240, R12 JMP callbackasm1(SB) MOVV $1241, R12 JMP callbackasm1(SB) MOVV $1242, R12 JMP callbackasm1(SB) MOVV $1243, R12 JMP callbackasm1(SB) MOVV $1244, R12 JMP callbackasm1(SB) MOVV $1245, R12 JMP callbackasm1(SB) MOVV $1246, R12 JMP callbackasm1(SB) MOVV $1247, R12 JMP callbackasm1(SB) MOVV $1248, R12 JMP callbackasm1(SB) MOVV $1249, R12 JMP callbackasm1(SB) MOVV $1250, R12 JMP callbackasm1(SB) MOVV $1251, R12 JMP callbackasm1(SB) MOVV $1252, R12 JMP callbackasm1(SB) MOVV $1253, R12 JMP callbackasm1(SB) MOVV $1254, R12 JMP callbackasm1(SB) MOVV $1255, R12 JMP callbackasm1(SB) MOVV $1256, R12 JMP callbackasm1(SB) MOVV $1257, R12 JMP callbackasm1(SB) MOVV $1258, R12 JMP callbackasm1(SB) MOVV $1259, R12 JMP callbackasm1(SB) MOVV $1260, R12 JMP callbackasm1(SB) MOVV $1261, R12 JMP callbackasm1(SB) MOVV $1262, R12 JMP callbackasm1(SB) MOVV $1263, R12 JMP callbackasm1(SB) MOVV $1264, R12 JMP callbackasm1(SB) MOVV $1265, R12 JMP callbackasm1(SB) MOVV $1266, R12 JMP callbackasm1(SB) MOVV $1267, R12 JMP callbackasm1(SB) MOVV $1268, R12 JMP callbackasm1(SB) MOVV $1269, R12 JMP callbackasm1(SB) MOVV $1270, R12 JMP callbackasm1(SB) MOVV $1271, R12 JMP callbackasm1(SB) MOVV $1272, R12 JMP callbackasm1(SB) MOVV $1273, R12 JMP callbackasm1(SB) MOVV $1274, R12 JMP callbackasm1(SB) MOVV $1275, R12 JMP callbackasm1(SB) MOVV $1276, R12 JMP callbackasm1(SB) MOVV $1277, R12 JMP callbackasm1(SB) MOVV $1278, R12 JMP callbackasm1(SB) MOVV $1279, R12 JMP callbackasm1(SB) MOVV $1280, R12 JMP callbackasm1(SB) MOVV $1281, R12 JMP callbackasm1(SB) MOVV $1282, R12 JMP callbackasm1(SB) MOVV $1283, R12 JMP callbackasm1(SB) MOVV $1284, R12 JMP callbackasm1(SB) MOVV $1285, R12 JMP callbackasm1(SB) MOVV $1286, R12 JMP callbackasm1(SB) MOVV $1287, R12 JMP callbackasm1(SB) MOVV $1288, R12 JMP callbackasm1(SB) MOVV $1289, R12 JMP callbackasm1(SB) MOVV $1290, R12 JMP callbackasm1(SB) MOVV $1291, R12 JMP callbackasm1(SB) MOVV $1292, R12 JMP callbackasm1(SB) MOVV $1293, R12 JMP callbackasm1(SB) MOVV $1294, R12 JMP callbackasm1(SB) MOVV $1295, R12 JMP callbackasm1(SB) MOVV $1296, R12 JMP callbackasm1(SB) MOVV $1297, R12 JMP callbackasm1(SB) MOVV $1298, R12 JMP callbackasm1(SB) MOVV $1299, R12 JMP callbackasm1(SB) MOVV $1300, R12 JMP callbackasm1(SB) MOVV $1301, R12 JMP callbackasm1(SB) MOVV $1302, R12 JMP callbackasm1(SB) MOVV $1303, R12 JMP callbackasm1(SB) MOVV $1304, R12 JMP callbackasm1(SB) MOVV $1305, R12 JMP callbackasm1(SB) MOVV $1306, R12 JMP callbackasm1(SB) MOVV $1307, R12 JMP callbackasm1(SB) MOVV $1308, R12 JMP callbackasm1(SB) MOVV $1309, R12 JMP callbackasm1(SB) MOVV $1310, R12 JMP callbackasm1(SB) MOVV $1311, R12 JMP callbackasm1(SB) MOVV $1312, R12 JMP callbackasm1(SB) MOVV $1313, R12 JMP callbackasm1(SB) MOVV $1314, R12 JMP callbackasm1(SB) MOVV $1315, R12 JMP callbackasm1(SB) MOVV $1316, R12 JMP callbackasm1(SB) MOVV $1317, R12 JMP callbackasm1(SB) MOVV $1318, R12 JMP callbackasm1(SB) MOVV $1319, R12 JMP callbackasm1(SB) MOVV $1320, R12 JMP callbackasm1(SB) MOVV $1321, R12 JMP callbackasm1(SB) MOVV $1322, R12 JMP callbackasm1(SB) MOVV $1323, R12 JMP callbackasm1(SB) MOVV $1324, R12 JMP callbackasm1(SB) MOVV $1325, R12 JMP callbackasm1(SB) MOVV $1326, R12 JMP callbackasm1(SB) MOVV $1327, R12 JMP callbackasm1(SB) MOVV $1328, R12 JMP callbackasm1(SB) MOVV $1329, R12 JMP callbackasm1(SB) MOVV $1330, R12 JMP callbackasm1(SB) MOVV $1331, R12 JMP callbackasm1(SB) MOVV $1332, R12 JMP callbackasm1(SB) MOVV $1333, R12 JMP callbackasm1(SB) MOVV $1334, R12 JMP callbackasm1(SB) MOVV $1335, R12 JMP callbackasm1(SB) MOVV $1336, R12 JMP callbackasm1(SB) MOVV $1337, R12 JMP callbackasm1(SB) MOVV $1338, R12 JMP callbackasm1(SB) MOVV $1339, R12 JMP callbackasm1(SB) MOVV $1340, R12 JMP callbackasm1(SB) MOVV $1341, R12 JMP callbackasm1(SB) MOVV $1342, R12 JMP callbackasm1(SB) MOVV $1343, R12 JMP callbackasm1(SB) MOVV $1344, R12 JMP callbackasm1(SB) MOVV $1345, R12 JMP callbackasm1(SB) MOVV $1346, R12 JMP callbackasm1(SB) MOVV $1347, R12 JMP callbackasm1(SB) MOVV $1348, R12 JMP callbackasm1(SB) MOVV $1349, R12 JMP callbackasm1(SB) MOVV $1350, R12 JMP callbackasm1(SB) MOVV $1351, R12 JMP callbackasm1(SB) MOVV $1352, R12 JMP callbackasm1(SB) MOVV $1353, R12 JMP callbackasm1(SB) MOVV $1354, R12 JMP callbackasm1(SB) MOVV $1355, R12 JMP callbackasm1(SB) MOVV $1356, R12 JMP callbackasm1(SB) MOVV $1357, R12 JMP callbackasm1(SB) MOVV $1358, R12 JMP callbackasm1(SB) MOVV $1359, R12 JMP callbackasm1(SB) MOVV $1360, R12 JMP callbackasm1(SB) MOVV $1361, R12 JMP callbackasm1(SB) MOVV $1362, R12 JMP callbackasm1(SB) MOVV $1363, R12 JMP callbackasm1(SB) MOVV $1364, R12 JMP callbackasm1(SB) MOVV $1365, R12 JMP callbackasm1(SB) MOVV $1366, R12 JMP callbackasm1(SB) MOVV $1367, R12 JMP callbackasm1(SB) MOVV $1368, R12 JMP callbackasm1(SB) MOVV $1369, R12 JMP callbackasm1(SB) MOVV $1370, R12 JMP callbackasm1(SB) MOVV $1371, R12 JMP callbackasm1(SB) MOVV $1372, R12 JMP callbackasm1(SB) MOVV $1373, R12 JMP callbackasm1(SB) MOVV $1374, R12 JMP callbackasm1(SB) MOVV $1375, R12 JMP callbackasm1(SB) MOVV $1376, R12 JMP callbackasm1(SB) MOVV $1377, R12 JMP callbackasm1(SB) MOVV $1378, R12 JMP callbackasm1(SB) MOVV $1379, R12 JMP callbackasm1(SB) MOVV $1380, R12 JMP callbackasm1(SB) MOVV $1381, R12 JMP callbackasm1(SB) MOVV $1382, R12 JMP callbackasm1(SB) MOVV $1383, R12 JMP callbackasm1(SB) MOVV $1384, R12 JMP callbackasm1(SB) MOVV $1385, R12 JMP callbackasm1(SB) MOVV $1386, R12 JMP callbackasm1(SB) MOVV $1387, R12 JMP callbackasm1(SB) MOVV $1388, R12 JMP callbackasm1(SB) MOVV $1389, R12 JMP callbackasm1(SB) MOVV $1390, R12 JMP callbackasm1(SB) MOVV $1391, R12 JMP callbackasm1(SB) MOVV $1392, R12 JMP callbackasm1(SB) MOVV $1393, R12 JMP callbackasm1(SB) MOVV $1394, R12 JMP callbackasm1(SB) MOVV $1395, R12 JMP callbackasm1(SB) MOVV $1396, R12 JMP callbackasm1(SB) MOVV $1397, R12 JMP callbackasm1(SB) MOVV $1398, R12 JMP callbackasm1(SB) MOVV $1399, R12 JMP callbackasm1(SB) MOVV $1400, R12 JMP callbackasm1(SB) MOVV $1401, R12 JMP callbackasm1(SB) MOVV $1402, R12 JMP callbackasm1(SB) MOVV $1403, R12 JMP callbackasm1(SB) MOVV $1404, R12 JMP callbackasm1(SB) MOVV $1405, R12 JMP callbackasm1(SB) MOVV $1406, R12 JMP callbackasm1(SB) MOVV $1407, R12 JMP callbackasm1(SB) MOVV $1408, R12 JMP callbackasm1(SB) MOVV $1409, R12 JMP callbackasm1(SB) MOVV $1410, R12 JMP callbackasm1(SB) MOVV $1411, R12 JMP callbackasm1(SB) MOVV $1412, R12 JMP callbackasm1(SB) MOVV $1413, R12 JMP callbackasm1(SB) MOVV $1414, R12 JMP callbackasm1(SB) MOVV $1415, R12 JMP callbackasm1(SB) MOVV $1416, R12 JMP callbackasm1(SB) MOVV $1417, R12 JMP callbackasm1(SB) MOVV $1418, R12 JMP callbackasm1(SB) MOVV $1419, R12 JMP callbackasm1(SB) MOVV $1420, R12 JMP callbackasm1(SB) MOVV $1421, R12 JMP callbackasm1(SB) MOVV $1422, R12 JMP callbackasm1(SB) MOVV $1423, R12 JMP callbackasm1(SB) MOVV $1424, R12 JMP callbackasm1(SB) MOVV $1425, R12 JMP callbackasm1(SB) MOVV $1426, R12 JMP callbackasm1(SB) MOVV $1427, R12 JMP callbackasm1(SB) MOVV $1428, R12 JMP callbackasm1(SB) MOVV $1429, R12 JMP callbackasm1(SB) MOVV $1430, R12 JMP callbackasm1(SB) MOVV $1431, R12 JMP callbackasm1(SB) MOVV $1432, R12 JMP callbackasm1(SB) MOVV $1433, R12 JMP callbackasm1(SB) MOVV $1434, R12 JMP callbackasm1(SB) MOVV $1435, R12 JMP callbackasm1(SB) MOVV $1436, R12 JMP callbackasm1(SB) MOVV $1437, R12 JMP callbackasm1(SB) MOVV $1438, R12 JMP callbackasm1(SB) MOVV $1439, R12 JMP callbackasm1(SB) MOVV $1440, R12 JMP callbackasm1(SB) MOVV $1441, R12 JMP callbackasm1(SB) MOVV $1442, R12 JMP callbackasm1(SB) MOVV $1443, R12 JMP callbackasm1(SB) MOVV $1444, R12 JMP callbackasm1(SB) MOVV $1445, R12 JMP callbackasm1(SB) MOVV $1446, R12 JMP callbackasm1(SB) MOVV $1447, R12 JMP callbackasm1(SB) MOVV $1448, R12 JMP callbackasm1(SB) MOVV $1449, R12 JMP callbackasm1(SB) MOVV $1450, R12 JMP callbackasm1(SB) MOVV $1451, R12 JMP callbackasm1(SB) MOVV $1452, R12 JMP callbackasm1(SB) MOVV $1453, R12 JMP callbackasm1(SB) MOVV $1454, R12 JMP callbackasm1(SB) MOVV $1455, R12 JMP callbackasm1(SB) MOVV $1456, R12 JMP callbackasm1(SB) MOVV $1457, R12 JMP callbackasm1(SB) MOVV $1458, R12 JMP callbackasm1(SB) MOVV $1459, R12 JMP callbackasm1(SB) MOVV $1460, R12 JMP callbackasm1(SB) MOVV $1461, R12 JMP callbackasm1(SB) MOVV $1462, R12 JMP callbackasm1(SB) MOVV $1463, R12 JMP callbackasm1(SB) MOVV $1464, R12 JMP callbackasm1(SB) MOVV $1465, R12 JMP callbackasm1(SB) MOVV $1466, R12 JMP callbackasm1(SB) MOVV $1467, R12 JMP callbackasm1(SB) MOVV $1468, R12 JMP callbackasm1(SB) MOVV $1469, R12 JMP callbackasm1(SB) MOVV $1470, R12 JMP callbackasm1(SB) MOVV $1471, R12 JMP callbackasm1(SB) MOVV $1472, R12 JMP callbackasm1(SB) MOVV $1473, R12 JMP callbackasm1(SB) MOVV $1474, R12 JMP callbackasm1(SB) MOVV $1475, R12 JMP callbackasm1(SB) MOVV $1476, R12 JMP callbackasm1(SB) MOVV $1477, R12 JMP callbackasm1(SB) MOVV $1478, R12 JMP callbackasm1(SB) MOVV $1479, R12 JMP callbackasm1(SB) MOVV $1480, R12 JMP callbackasm1(SB) MOVV $1481, R12 JMP callbackasm1(SB) MOVV $1482, R12 JMP callbackasm1(SB) MOVV $1483, R12 JMP callbackasm1(SB) MOVV $1484, R12 JMP callbackasm1(SB) MOVV $1485, R12 JMP callbackasm1(SB) MOVV $1486, R12 JMP callbackasm1(SB) MOVV $1487, R12 JMP callbackasm1(SB) MOVV $1488, R12 JMP callbackasm1(SB) MOVV $1489, R12 JMP callbackasm1(SB) MOVV $1490, R12 JMP callbackasm1(SB) MOVV $1491, R12 JMP callbackasm1(SB) MOVV $1492, R12 JMP callbackasm1(SB) MOVV $1493, R12 JMP callbackasm1(SB) MOVV $1494, R12 JMP callbackasm1(SB) MOVV $1495, R12 JMP callbackasm1(SB) MOVV $1496, R12 JMP callbackasm1(SB) MOVV $1497, R12 JMP callbackasm1(SB) MOVV $1498, R12 JMP callbackasm1(SB) MOVV $1499, R12 JMP callbackasm1(SB) MOVV $1500, R12 JMP callbackasm1(SB) MOVV $1501, R12 JMP callbackasm1(SB) MOVV $1502, R12 JMP callbackasm1(SB) MOVV $1503, R12 JMP callbackasm1(SB) MOVV $1504, R12 JMP callbackasm1(SB) MOVV $1505, R12 JMP callbackasm1(SB) MOVV $1506, R12 JMP callbackasm1(SB) MOVV $1507, R12 JMP callbackasm1(SB) MOVV $1508, R12 JMP callbackasm1(SB) MOVV $1509, R12 JMP callbackasm1(SB) MOVV $1510, R12 JMP callbackasm1(SB) MOVV $1511, R12 JMP callbackasm1(SB) MOVV $1512, R12 JMP callbackasm1(SB) MOVV $1513, R12 JMP callbackasm1(SB) MOVV $1514, R12 JMP callbackasm1(SB) MOVV $1515, R12 JMP callbackasm1(SB) MOVV $1516, R12 JMP callbackasm1(SB) MOVV $1517, R12 JMP callbackasm1(SB) MOVV $1518, R12 JMP callbackasm1(SB) MOVV $1519, R12 JMP callbackasm1(SB) MOVV $1520, R12 JMP callbackasm1(SB) MOVV $1521, R12 JMP callbackasm1(SB) MOVV $1522, R12 JMP callbackasm1(SB) MOVV $1523, R12 JMP callbackasm1(SB) MOVV $1524, R12 JMP callbackasm1(SB) MOVV $1525, R12 JMP callbackasm1(SB) MOVV $1526, R12 JMP callbackasm1(SB) MOVV $1527, R12 JMP callbackasm1(SB) MOVV $1528, R12 JMP callbackasm1(SB) MOVV $1529, R12 JMP callbackasm1(SB) MOVV $1530, R12 JMP callbackasm1(SB) MOVV $1531, R12 JMP callbackasm1(SB) MOVV $1532, R12 JMP callbackasm1(SB) MOVV $1533, R12 JMP callbackasm1(SB) MOVV $1534, R12 JMP callbackasm1(SB) MOVV $1535, R12 JMP callbackasm1(SB) MOVV $1536, R12 JMP callbackasm1(SB) MOVV $1537, R12 JMP callbackasm1(SB) MOVV $1538, R12 JMP callbackasm1(SB) MOVV $1539, R12 JMP callbackasm1(SB) MOVV $1540, R12 JMP callbackasm1(SB) MOVV $1541, R12 JMP callbackasm1(SB) MOVV $1542, R12 JMP callbackasm1(SB) MOVV $1543, R12 JMP callbackasm1(SB) MOVV $1544, R12 JMP callbackasm1(SB) MOVV $1545, R12 JMP callbackasm1(SB) MOVV $1546, R12 JMP callbackasm1(SB) MOVV $1547, R12 JMP callbackasm1(SB) MOVV $1548, R12 JMP callbackasm1(SB) MOVV $1549, R12 JMP callbackasm1(SB) MOVV $1550, R12 JMP callbackasm1(SB) MOVV $1551, R12 JMP callbackasm1(SB) MOVV $1552, R12 JMP callbackasm1(SB) MOVV $1553, R12 JMP callbackasm1(SB) MOVV $1554, R12 JMP callbackasm1(SB) MOVV $1555, R12 JMP callbackasm1(SB) MOVV $1556, R12 JMP callbackasm1(SB) MOVV $1557, R12 JMP callbackasm1(SB) MOVV $1558, R12 JMP callbackasm1(SB) MOVV $1559, R12 JMP callbackasm1(SB) MOVV $1560, R12 JMP callbackasm1(SB) MOVV $1561, R12 JMP callbackasm1(SB) MOVV $1562, R12 JMP callbackasm1(SB) MOVV $1563, R12 JMP callbackasm1(SB) MOVV $1564, R12 JMP callbackasm1(SB) MOVV $1565, R12 JMP callbackasm1(SB) MOVV $1566, R12 JMP callbackasm1(SB) MOVV $1567, R12 JMP callbackasm1(SB) MOVV $1568, R12 JMP callbackasm1(SB) MOVV $1569, R12 JMP callbackasm1(SB) MOVV $1570, R12 JMP callbackasm1(SB) MOVV $1571, R12 JMP callbackasm1(SB) MOVV $1572, R12 JMP callbackasm1(SB) MOVV $1573, R12 JMP callbackasm1(SB) MOVV $1574, R12 JMP callbackasm1(SB) MOVV $1575, R12 JMP callbackasm1(SB) MOVV $1576, R12 JMP callbackasm1(SB) MOVV $1577, R12 JMP callbackasm1(SB) MOVV $1578, R12 JMP callbackasm1(SB) MOVV $1579, R12 JMP callbackasm1(SB) MOVV $1580, R12 JMP callbackasm1(SB) MOVV $1581, R12 JMP callbackasm1(SB) MOVV $1582, R12 JMP callbackasm1(SB) MOVV $1583, R12 JMP callbackasm1(SB) MOVV $1584, R12 JMP callbackasm1(SB) MOVV $1585, R12 JMP callbackasm1(SB) MOVV $1586, R12 JMP callbackasm1(SB) MOVV $1587, R12 JMP callbackasm1(SB) MOVV $1588, R12 JMP callbackasm1(SB) MOVV $1589, R12 JMP callbackasm1(SB) MOVV $1590, R12 JMP callbackasm1(SB) MOVV $1591, R12 JMP callbackasm1(SB) MOVV $1592, R12 JMP callbackasm1(SB) MOVV $1593, R12 JMP callbackasm1(SB) MOVV $1594, R12 JMP callbackasm1(SB) MOVV $1595, R12 JMP callbackasm1(SB) MOVV $1596, R12 JMP callbackasm1(SB) MOVV $1597, R12 JMP callbackasm1(SB) MOVV $1598, R12 JMP callbackasm1(SB) MOVV $1599, R12 JMP callbackasm1(SB) MOVV $1600, R12 JMP callbackasm1(SB) MOVV $1601, R12 JMP callbackasm1(SB) MOVV $1602, R12 JMP callbackasm1(SB) MOVV $1603, R12 JMP callbackasm1(SB) MOVV $1604, R12 JMP callbackasm1(SB) MOVV $1605, R12 JMP callbackasm1(SB) MOVV $1606, R12 JMP callbackasm1(SB) MOVV $1607, R12 JMP callbackasm1(SB) MOVV $1608, R12 JMP callbackasm1(SB) MOVV $1609, R12 JMP callbackasm1(SB) MOVV $1610, R12 JMP callbackasm1(SB) MOVV $1611, R12 JMP callbackasm1(SB) MOVV $1612, R12 JMP callbackasm1(SB) MOVV $1613, R12 JMP callbackasm1(SB) MOVV $1614, R12 JMP callbackasm1(SB) MOVV $1615, R12 JMP callbackasm1(SB) MOVV $1616, R12 JMP callbackasm1(SB) MOVV $1617, R12 JMP callbackasm1(SB) MOVV $1618, R12 JMP callbackasm1(SB) MOVV $1619, R12 JMP callbackasm1(SB) MOVV $1620, R12 JMP callbackasm1(SB) MOVV $1621, R12 JMP callbackasm1(SB) MOVV $1622, R12 JMP callbackasm1(SB) MOVV $1623, R12 JMP callbackasm1(SB) MOVV $1624, R12 JMP callbackasm1(SB) MOVV $1625, R12 JMP callbackasm1(SB) MOVV $1626, R12 JMP callbackasm1(SB) MOVV $1627, R12 JMP callbackasm1(SB) MOVV $1628, R12 JMP callbackasm1(SB) MOVV $1629, R12 JMP callbackasm1(SB) MOVV $1630, R12 JMP callbackasm1(SB) MOVV $1631, R12 JMP callbackasm1(SB) MOVV $1632, R12 JMP callbackasm1(SB) MOVV $1633, R12 JMP callbackasm1(SB) MOVV $1634, R12 JMP callbackasm1(SB) MOVV $1635, R12 JMP callbackasm1(SB) MOVV $1636, R12 JMP callbackasm1(SB) MOVV $1637, R12 JMP callbackasm1(SB) MOVV $1638, R12 JMP callbackasm1(SB) MOVV $1639, R12 JMP callbackasm1(SB) MOVV $1640, R12 JMP callbackasm1(SB) MOVV $1641, R12 JMP callbackasm1(SB) MOVV $1642, R12 JMP callbackasm1(SB) MOVV $1643, R12 JMP callbackasm1(SB) MOVV $1644, R12 JMP callbackasm1(SB) MOVV $1645, R12 JMP callbackasm1(SB) MOVV $1646, R12 JMP callbackasm1(SB) MOVV $1647, R12 JMP callbackasm1(SB) MOVV $1648, R12 JMP callbackasm1(SB) MOVV $1649, R12 JMP callbackasm1(SB) MOVV $1650, R12 JMP callbackasm1(SB) MOVV $1651, R12 JMP callbackasm1(SB) MOVV $1652, R12 JMP callbackasm1(SB) MOVV $1653, R12 JMP callbackasm1(SB) MOVV $1654, R12 JMP callbackasm1(SB) MOVV $1655, R12 JMP callbackasm1(SB) MOVV $1656, R12 JMP callbackasm1(SB) MOVV $1657, R12 JMP callbackasm1(SB) MOVV $1658, R12 JMP callbackasm1(SB) MOVV $1659, R12 JMP callbackasm1(SB) MOVV $1660, R12 JMP callbackasm1(SB) MOVV $1661, R12 JMP callbackasm1(SB) MOVV $1662, R12 JMP callbackasm1(SB) MOVV $1663, R12 JMP callbackasm1(SB) MOVV $1664, R12 JMP callbackasm1(SB) MOVV $1665, R12 JMP callbackasm1(SB) MOVV $1666, R12 JMP callbackasm1(SB) MOVV $1667, R12 JMP callbackasm1(SB) MOVV $1668, R12 JMP callbackasm1(SB) MOVV $1669, R12 JMP callbackasm1(SB) MOVV $1670, R12 JMP callbackasm1(SB) MOVV $1671, R12 JMP callbackasm1(SB) MOVV $1672, R12 JMP callbackasm1(SB) MOVV $1673, R12 JMP callbackasm1(SB) MOVV $1674, R12 JMP callbackasm1(SB) MOVV $1675, R12 JMP callbackasm1(SB) MOVV $1676, R12 JMP callbackasm1(SB) MOVV $1677, R12 JMP callbackasm1(SB) MOVV $1678, R12 JMP callbackasm1(SB) MOVV $1679, R12 JMP callbackasm1(SB) MOVV $1680, R12 JMP callbackasm1(SB) MOVV $1681, R12 JMP callbackasm1(SB) MOVV $1682, R12 JMP callbackasm1(SB) MOVV $1683, R12 JMP callbackasm1(SB) MOVV $1684, R12 JMP callbackasm1(SB) MOVV $1685, R12 JMP callbackasm1(SB) MOVV $1686, R12 JMP callbackasm1(SB) MOVV $1687, R12 JMP callbackasm1(SB) MOVV $1688, R12 JMP callbackasm1(SB) MOVV $1689, R12 JMP callbackasm1(SB) MOVV $1690, R12 JMP callbackasm1(SB) MOVV $1691, R12 JMP callbackasm1(SB) MOVV $1692, R12 JMP callbackasm1(SB) MOVV $1693, R12 JMP callbackasm1(SB) MOVV $1694, R12 JMP callbackasm1(SB) MOVV $1695, R12 JMP callbackasm1(SB) MOVV $1696, R12 JMP callbackasm1(SB) MOVV $1697, R12 JMP callbackasm1(SB) MOVV $1698, R12 JMP callbackasm1(SB) MOVV $1699, R12 JMP callbackasm1(SB) MOVV $1700, R12 JMP callbackasm1(SB) MOVV $1701, R12 JMP callbackasm1(SB) MOVV $1702, R12 JMP callbackasm1(SB) MOVV $1703, R12 JMP callbackasm1(SB) MOVV $1704, R12 JMP callbackasm1(SB) MOVV $1705, R12 JMP callbackasm1(SB) MOVV $1706, R12 JMP callbackasm1(SB) MOVV $1707, R12 JMP callbackasm1(SB) MOVV $1708, R12 JMP callbackasm1(SB) MOVV $1709, R12 JMP callbackasm1(SB) MOVV $1710, R12 JMP callbackasm1(SB) MOVV $1711, R12 JMP callbackasm1(SB) MOVV $1712, R12 JMP callbackasm1(SB) MOVV $1713, R12 JMP callbackasm1(SB) MOVV $1714, R12 JMP callbackasm1(SB) MOVV $1715, R12 JMP callbackasm1(SB) MOVV $1716, R12 JMP callbackasm1(SB) MOVV $1717, R12 JMP callbackasm1(SB) MOVV $1718, R12 JMP callbackasm1(SB) MOVV $1719, R12 JMP callbackasm1(SB) MOVV $1720, R12 JMP callbackasm1(SB) MOVV $1721, R12 JMP callbackasm1(SB) MOVV $1722, R12 JMP callbackasm1(SB) MOVV $1723, R12 JMP callbackasm1(SB) MOVV $1724, R12 JMP callbackasm1(SB) MOVV $1725, R12 JMP callbackasm1(SB) MOVV $1726, R12 JMP callbackasm1(SB) MOVV $1727, R12 JMP callbackasm1(SB) MOVV $1728, R12 JMP callbackasm1(SB) MOVV $1729, R12 JMP callbackasm1(SB) MOVV $1730, R12 JMP callbackasm1(SB) MOVV $1731, R12 JMP callbackasm1(SB) MOVV $1732, R12 JMP callbackasm1(SB) MOVV $1733, R12 JMP callbackasm1(SB) MOVV $1734, R12 JMP callbackasm1(SB) MOVV $1735, R12 JMP callbackasm1(SB) MOVV $1736, R12 JMP callbackasm1(SB) MOVV $1737, R12 JMP callbackasm1(SB) MOVV $1738, R12 JMP callbackasm1(SB) MOVV $1739, R12 JMP callbackasm1(SB) MOVV $1740, R12 JMP callbackasm1(SB) MOVV $1741, R12 JMP callbackasm1(SB) MOVV $1742, R12 JMP callbackasm1(SB) MOVV $1743, R12 JMP callbackasm1(SB) MOVV $1744, R12 JMP callbackasm1(SB) MOVV $1745, R12 JMP callbackasm1(SB) MOVV $1746, R12 JMP callbackasm1(SB) MOVV $1747, R12 JMP callbackasm1(SB) MOVV $1748, R12 JMP callbackasm1(SB) MOVV $1749, R12 JMP callbackasm1(SB) MOVV $1750, R12 JMP callbackasm1(SB) MOVV $1751, R12 JMP callbackasm1(SB) MOVV $1752, R12 JMP callbackasm1(SB) MOVV $1753, R12 JMP callbackasm1(SB) MOVV $1754, R12 JMP callbackasm1(SB) MOVV $1755, R12 JMP callbackasm1(SB) MOVV $1756, R12 JMP callbackasm1(SB) MOVV $1757, R12 JMP callbackasm1(SB) MOVV $1758, R12 JMP callbackasm1(SB) MOVV $1759, R12 JMP callbackasm1(SB) MOVV $1760, R12 JMP callbackasm1(SB) MOVV $1761, R12 JMP callbackasm1(SB) MOVV $1762, R12 JMP callbackasm1(SB) MOVV $1763, R12 JMP callbackasm1(SB) MOVV $1764, R12 JMP callbackasm1(SB) MOVV $1765, R12 JMP callbackasm1(SB) MOVV $1766, R12 JMP callbackasm1(SB) MOVV $1767, R12 JMP callbackasm1(SB) MOVV $1768, R12 JMP callbackasm1(SB) MOVV $1769, R12 JMP callbackasm1(SB) MOVV $1770, R12 JMP callbackasm1(SB) MOVV $1771, R12 JMP callbackasm1(SB) MOVV $1772, R12 JMP callbackasm1(SB) MOVV $1773, R12 JMP callbackasm1(SB) MOVV $1774, R12 JMP callbackasm1(SB) MOVV $1775, R12 JMP callbackasm1(SB) MOVV $1776, R12 JMP callbackasm1(SB) MOVV $1777, R12 JMP callbackasm1(SB) MOVV $1778, R12 JMP callbackasm1(SB) MOVV $1779, R12 JMP callbackasm1(SB) MOVV $1780, R12 JMP callbackasm1(SB) MOVV $1781, R12 JMP callbackasm1(SB) MOVV $1782, R12 JMP callbackasm1(SB) MOVV $1783, R12 JMP callbackasm1(SB) MOVV $1784, R12 JMP callbackasm1(SB) MOVV $1785, R12 JMP callbackasm1(SB) MOVV $1786, R12 JMP callbackasm1(SB) MOVV $1787, R12 JMP callbackasm1(SB) MOVV $1788, R12 JMP callbackasm1(SB) MOVV $1789, R12 JMP callbackasm1(SB) MOVV $1790, R12 JMP callbackasm1(SB) MOVV $1791, R12 JMP callbackasm1(SB) MOVV $1792, R12 JMP callbackasm1(SB) MOVV $1793, R12 JMP callbackasm1(SB) MOVV $1794, R12 JMP callbackasm1(SB) MOVV $1795, R12 JMP callbackasm1(SB) MOVV $1796, R12 JMP callbackasm1(SB) MOVV $1797, R12 JMP callbackasm1(SB) MOVV $1798, R12 JMP callbackasm1(SB) MOVV $1799, R12 JMP callbackasm1(SB) MOVV $1800, R12 JMP callbackasm1(SB) MOVV $1801, R12 JMP callbackasm1(SB) MOVV $1802, R12 JMP callbackasm1(SB) MOVV $1803, R12 JMP callbackasm1(SB) MOVV $1804, R12 JMP callbackasm1(SB) MOVV $1805, R12 JMP callbackasm1(SB) MOVV $1806, R12 JMP callbackasm1(SB) MOVV $1807, R12 JMP callbackasm1(SB) MOVV $1808, R12 JMP callbackasm1(SB) MOVV $1809, R12 JMP callbackasm1(SB) MOVV $1810, R12 JMP callbackasm1(SB) MOVV $1811, R12 JMP callbackasm1(SB) MOVV $1812, R12 JMP callbackasm1(SB) MOVV $1813, R12 JMP callbackasm1(SB) MOVV $1814, R12 JMP callbackasm1(SB) MOVV $1815, R12 JMP callbackasm1(SB) MOVV $1816, R12 JMP callbackasm1(SB) MOVV $1817, R12 JMP callbackasm1(SB) MOVV $1818, R12 JMP callbackasm1(SB) MOVV $1819, R12 JMP callbackasm1(SB) MOVV $1820, R12 JMP callbackasm1(SB) MOVV $1821, R12 JMP callbackasm1(SB) MOVV $1822, R12 JMP callbackasm1(SB) MOVV $1823, R12 JMP callbackasm1(SB) MOVV $1824, R12 JMP callbackasm1(SB) MOVV $1825, R12 JMP callbackasm1(SB) MOVV $1826, R12 JMP callbackasm1(SB) MOVV $1827, R12 JMP callbackasm1(SB) MOVV $1828, R12 JMP callbackasm1(SB) MOVV $1829, R12 JMP callbackasm1(SB) MOVV $1830, R12 JMP callbackasm1(SB) MOVV $1831, R12 JMP callbackasm1(SB) MOVV $1832, R12 JMP callbackasm1(SB) MOVV $1833, R12 JMP callbackasm1(SB) MOVV $1834, R12 JMP callbackasm1(SB) MOVV $1835, R12 JMP callbackasm1(SB) MOVV $1836, R12 JMP callbackasm1(SB) MOVV $1837, R12 JMP callbackasm1(SB) MOVV $1838, R12 JMP callbackasm1(SB) MOVV $1839, R12 JMP callbackasm1(SB) MOVV $1840, R12 JMP callbackasm1(SB) MOVV $1841, R12 JMP callbackasm1(SB) MOVV $1842, R12 JMP callbackasm1(SB) MOVV $1843, R12 JMP callbackasm1(SB) MOVV $1844, R12 JMP callbackasm1(SB) MOVV $1845, R12 JMP callbackasm1(SB) MOVV $1846, R12 JMP callbackasm1(SB) MOVV $1847, R12 JMP callbackasm1(SB) MOVV $1848, R12 JMP callbackasm1(SB) MOVV $1849, R12 JMP callbackasm1(SB) MOVV $1850, R12 JMP callbackasm1(SB) MOVV $1851, R12 JMP callbackasm1(SB) MOVV $1852, R12 JMP callbackasm1(SB) MOVV $1853, R12 JMP callbackasm1(SB) MOVV $1854, R12 JMP callbackasm1(SB) MOVV $1855, R12 JMP callbackasm1(SB) MOVV $1856, R12 JMP callbackasm1(SB) MOVV $1857, R12 JMP callbackasm1(SB) MOVV $1858, R12 JMP callbackasm1(SB) MOVV $1859, R12 JMP callbackasm1(SB) MOVV $1860, R12 JMP callbackasm1(SB) MOVV $1861, R12 JMP callbackasm1(SB) MOVV $1862, R12 JMP callbackasm1(SB) MOVV $1863, R12 JMP callbackasm1(SB) MOVV $1864, R12 JMP callbackasm1(SB) MOVV $1865, R12 JMP callbackasm1(SB) MOVV $1866, R12 JMP callbackasm1(SB) MOVV $1867, R12 JMP callbackasm1(SB) MOVV $1868, R12 JMP callbackasm1(SB) MOVV $1869, R12 JMP callbackasm1(SB) MOVV $1870, R12 JMP callbackasm1(SB) MOVV $1871, R12 JMP callbackasm1(SB) MOVV $1872, R12 JMP callbackasm1(SB) MOVV $1873, R12 JMP callbackasm1(SB) MOVV $1874, R12 JMP callbackasm1(SB) MOVV $1875, R12 JMP callbackasm1(SB) MOVV $1876, R12 JMP callbackasm1(SB) MOVV $1877, R12 JMP callbackasm1(SB) MOVV $1878, R12 JMP callbackasm1(SB) MOVV $1879, R12 JMP callbackasm1(SB) MOVV $1880, R12 JMP callbackasm1(SB) MOVV $1881, R12 JMP callbackasm1(SB) MOVV $1882, R12 JMP callbackasm1(SB) MOVV $1883, R12 JMP callbackasm1(SB) MOVV $1884, R12 JMP callbackasm1(SB) MOVV $1885, R12 JMP callbackasm1(SB) MOVV $1886, R12 JMP callbackasm1(SB) MOVV $1887, R12 JMP callbackasm1(SB) MOVV $1888, R12 JMP callbackasm1(SB) MOVV $1889, R12 JMP callbackasm1(SB) MOVV $1890, R12 JMP callbackasm1(SB) MOVV $1891, R12 JMP callbackasm1(SB) MOVV $1892, R12 JMP callbackasm1(SB) MOVV $1893, R12 JMP callbackasm1(SB) MOVV $1894, R12 JMP callbackasm1(SB) MOVV $1895, R12 JMP callbackasm1(SB) MOVV $1896, R12 JMP callbackasm1(SB) MOVV $1897, R12 JMP callbackasm1(SB) MOVV $1898, R12 JMP callbackasm1(SB) MOVV $1899, R12 JMP callbackasm1(SB) MOVV $1900, R12 JMP callbackasm1(SB) MOVV $1901, R12 JMP callbackasm1(SB) MOVV $1902, R12 JMP callbackasm1(SB) MOVV $1903, R12 JMP callbackasm1(SB) MOVV $1904, R12 JMP callbackasm1(SB) MOVV $1905, R12 JMP callbackasm1(SB) MOVV $1906, R12 JMP callbackasm1(SB) MOVV $1907, R12 JMP callbackasm1(SB) MOVV $1908, R12 JMP callbackasm1(SB) MOVV $1909, R12 JMP callbackasm1(SB) MOVV $1910, R12 JMP callbackasm1(SB) MOVV $1911, R12 JMP callbackasm1(SB) MOVV $1912, R12 JMP callbackasm1(SB) MOVV $1913, R12 JMP callbackasm1(SB) MOVV $1914, R12 JMP callbackasm1(SB) MOVV $1915, R12 JMP callbackasm1(SB) MOVV $1916, R12 JMP callbackasm1(SB) MOVV $1917, R12 JMP callbackasm1(SB) MOVV $1918, R12 JMP callbackasm1(SB) MOVV $1919, R12 JMP callbackasm1(SB) MOVV $1920, R12 JMP callbackasm1(SB) MOVV $1921, R12 JMP callbackasm1(SB) MOVV $1922, R12 JMP callbackasm1(SB) MOVV $1923, R12 JMP callbackasm1(SB) MOVV $1924, R12 JMP callbackasm1(SB) MOVV $1925, R12 JMP callbackasm1(SB) MOVV $1926, R12 JMP callbackasm1(SB) MOVV $1927, R12 JMP callbackasm1(SB) MOVV $1928, R12 JMP callbackasm1(SB) MOVV $1929, R12 JMP callbackasm1(SB) MOVV $1930, R12 JMP callbackasm1(SB) MOVV $1931, R12 JMP callbackasm1(SB) MOVV $1932, R12 JMP callbackasm1(SB) MOVV $1933, R12 JMP callbackasm1(SB) MOVV $1934, R12 JMP callbackasm1(SB) MOVV $1935, R12 JMP callbackasm1(SB) MOVV $1936, R12 JMP callbackasm1(SB) MOVV $1937, R12 JMP callbackasm1(SB) MOVV $1938, R12 JMP callbackasm1(SB) MOVV $1939, R12 JMP callbackasm1(SB) MOVV $1940, R12 JMP callbackasm1(SB) MOVV $1941, R12 JMP callbackasm1(SB) MOVV $1942, R12 JMP callbackasm1(SB) MOVV $1943, R12 JMP callbackasm1(SB) MOVV $1944, R12 JMP callbackasm1(SB) MOVV $1945, R12 JMP callbackasm1(SB) MOVV $1946, R12 JMP callbackasm1(SB) MOVV $1947, R12 JMP callbackasm1(SB) MOVV $1948, R12 JMP callbackasm1(SB) MOVV $1949, R12 JMP callbackasm1(SB) MOVV $1950, R12 JMP callbackasm1(SB) MOVV $1951, R12 JMP callbackasm1(SB) MOVV $1952, R12 JMP callbackasm1(SB) MOVV $1953, R12 JMP callbackasm1(SB) MOVV $1954, R12 JMP callbackasm1(SB) MOVV $1955, R12 JMP callbackasm1(SB) MOVV $1956, R12 JMP callbackasm1(SB) MOVV $1957, R12 JMP callbackasm1(SB) MOVV $1958, R12 JMP callbackasm1(SB) MOVV $1959, R12 JMP callbackasm1(SB) MOVV $1960, R12 JMP callbackasm1(SB) MOVV $1961, R12 JMP callbackasm1(SB) MOVV $1962, R12 JMP callbackasm1(SB) MOVV $1963, R12 JMP callbackasm1(SB) MOVV $1964, R12 JMP callbackasm1(SB) MOVV $1965, R12 JMP callbackasm1(SB) MOVV $1966, R12 JMP callbackasm1(SB) MOVV $1967, R12 JMP callbackasm1(SB) MOVV $1968, R12 JMP callbackasm1(SB) MOVV $1969, R12 JMP callbackasm1(SB) MOVV $1970, R12 JMP callbackasm1(SB) MOVV $1971, R12 JMP callbackasm1(SB) MOVV $1972, R12 JMP callbackasm1(SB) MOVV $1973, R12 JMP callbackasm1(SB) MOVV $1974, R12 JMP callbackasm1(SB) MOVV $1975, R12 JMP callbackasm1(SB) MOVV $1976, R12 JMP callbackasm1(SB) MOVV $1977, R12 JMP callbackasm1(SB) MOVV $1978, R12 JMP callbackasm1(SB) MOVV $1979, R12 JMP callbackasm1(SB) MOVV $1980, R12 JMP callbackasm1(SB) MOVV $1981, R12 JMP callbackasm1(SB) MOVV $1982, R12 JMP callbackasm1(SB) MOVV $1983, R12 JMP callbackasm1(SB) MOVV $1984, R12 JMP callbackasm1(SB) MOVV $1985, R12 JMP callbackasm1(SB) MOVV $1986, R12 JMP callbackasm1(SB) MOVV $1987, R12 JMP callbackasm1(SB) MOVV $1988, R12 JMP callbackasm1(SB) MOVV $1989, R12 JMP callbackasm1(SB) MOVV $1990, R12 JMP callbackasm1(SB) MOVV $1991, R12 JMP callbackasm1(SB) MOVV $1992, R12 JMP callbackasm1(SB) MOVV $1993, R12 JMP callbackasm1(SB) MOVV $1994, R12 JMP callbackasm1(SB) MOVV $1995, R12 JMP callbackasm1(SB) MOVV $1996, R12 JMP callbackasm1(SB) MOVV $1997, R12 JMP callbackasm1(SB) MOVV $1998, R12 JMP callbackasm1(SB) MOVV $1999, R12 JMP callbackasm1(SB)